fix(spanish-md): Address some formatting issues for Spanish md
This commit is contained in:
Bouncey
committed by
mrugesh mohapatra
mrugesh mohapatra
parent
ee9f6b2d72
commit
c2a45b58be
@@ -6,14 +6,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Cree una función que tome dos o más matrices y devuelva una matriz de la <dfn>diferencia simétrica</dfn> ( <code>△</code> o <code>⊕</code> ) de las matrices proporcionadas.
|
||||
Dado dos conjuntos (por ejemplo, conjunto <code>A = {1, 2, 3}</code> y conjunto <code>B = {2, 3, 4}</code> ), el término matemático "diferencia simétrica" es el conjunto de elementos que se encuentran en cualquiera de los dos conjuntos, pero no en ambos ( <code>A △ B = C = {1, 4}</code> ). Por cada diferencia simétrica adicional que tome (por ejemplo, en un conjunto <code>D = {2, 3}</code> ), debe obtener el conjunto con elementos que están en cualquiera de los dos conjuntos pero no en ambos ( <code>C △ D = {1, 4} △ {2, 3} = {1, 2, 3, 4}</code> ). La matriz resultante debe contener solo valores únicos ( <em>no duplicados</em> ).
|
||||
Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
|
||||
<section id='description'>
|
||||
Cree una función que tome dos o más matrices y devuelva una matriz de la <dfn>diferencia simétrica</dfn> ( <code>△</code> o <code>⊕</code> ) de las matrices proporcionadas.
|
||||
Dado dos conjuntos (por ejemplo, conjunto <code>A = {1, 2, 3}</code> y conjunto <code>B = {2, 3, 4}</code> ), el término matemático "diferencia simétrica" es el conjunto de elementos que se encuentran en cualquiera de los dos conjuntos, pero no en ambos ( <code>A △ B = C = {1, 4}</code> ). Por cada diferencia simétrica adicional que tome (por ejemplo, en un conjunto <code>D = {2, 3}</code> ), debe obtener el conjunto con elementos que están en cualquiera de los dos conjuntos pero no en ambos ( <code>C △ D = {1, 4} △ {2, 3} = {1, 2, 3, 4}</code> ). La matriz resultante debe contener solo valores únicos ( <em>no duplicados</em> ).
|
||||
Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -22,33 +22,33 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>sym([1, 2, 3], [5, 2, 1, 4])</code> debe devolver <code>[3, 4, 5]</code> .'
|
||||
- text: ' <code>sym([1, 2, 3], [5, 2, 1, 4])</code> debe devolver <code>[3, 4, 5]</code> .'
|
||||
testString: 'assert.sameMembers(sym([1, 2, 3], [5, 2, 1, 4]), [3, 4, 5], "<code>sym([1, 2, 3], [5, 2, 1, 4])</code> should return <code>[3, 4, 5]</code>.");'
|
||||
- text: ' <code>sym([1, 2, 3], [5, 2, 1, 4])</code> debe contener solo tres elementos.'
|
||||
- text: ' <code>sym([1, 2, 3], [5, 2, 1, 4])</code> debe contener solo tres elementos.'
|
||||
testString: 'assert.equal(sym([1, 2, 3], [5, 2, 1, 4]).length, 3, "<code>sym([1, 2, 3], [5, 2, 1, 4])</code> should contain only three elements.");'
|
||||
- text: ' <code>sym([1, 2, 3, 3], [5, 2, 1, 4])</code> debe devolver <code>[3, 4, 5]</code> .'
|
||||
- text: ' <code>sym([1, 2, 3, 3], [5, 2, 1, 4])</code> debe devolver <code>[3, 4, 5]</code> .'
|
||||
testString: 'assert.sameMembers(sym([1, 2, 3, 3], [5, 2, 1, 4]), [3, 4, 5], "<code>sym([1, 2, 3, 3], [5, 2, 1, 4])</code> should return <code>[3, 4, 5]</code>.");'
|
||||
- text: ' <code>sym([1, 2, 3, 3], [5, 2, 1, 4])</code> debe contener solo tres elementos.'
|
||||
- text: ' <code>sym([1, 2, 3, 3], [5, 2, 1, 4])</code> debe contener solo tres elementos.'
|
||||
testString: 'assert.equal(sym([1, 2, 3, 3], [5, 2, 1, 4]).length, 3, "<code>sym([1, 2, 3, 3], [5, 2, 1, 4])</code> should contain only three elements.");'
|
||||
- text: ' <code>sym([1, 2, 3], [5, 2, 1, 4, 5])</code> debe devolver <code>[3, 4, 5]</code> .'
|
||||
- text: ' <code>sym([1, 2, 3], [5, 2, 1, 4, 5])</code> debe devolver <code>[3, 4, 5]</code> .'
|
||||
testString: 'assert.sameMembers(sym([1, 2, 3], [5, 2, 1, 4, 5]), [3, 4, 5], "<code>sym([1, 2, 3], [5, 2, 1, 4, 5])</code> should return <code>[3, 4, 5]</code>.");'
|
||||
- text: ' <code>sym([1, 2, 3], [5, 2, 1, 4, 5])</code> debe contener solo tres elementos.'
|
||||
- text: ' <code>sym([1, 2, 3], [5, 2, 1, 4, 5])</code> debe contener solo tres elementos.'
|
||||
testString: 'assert.equal(sym([1, 2, 3], [5, 2, 1, 4, 5]).length, 3, "<code>sym([1, 2, 3], [5, 2, 1, 4, 5])</code> should contain only three elements.");'
|
||||
- text: ' <code>sym([1, 2, 5], [2, 3, 5], [3, 4, 5])</code> debe devolver <code>[1, 4, 5]</code> '
|
||||
- text: ' <code>sym([1, 2, 5], [2, 3, 5], [3, 4, 5])</code> debe devolver <code>[1, 4, 5]</code> '
|
||||
testString: 'assert.sameMembers(sym([1, 2, 5], [2, 3, 5], [3, 4, 5]), [1, 4, 5], "<code>sym([1, 2, 5], [2, 3, 5], [3, 4, 5])</code> should return <code>[1, 4, 5]</code>");'
|
||||
- text: ' <code>sym([1, 2, 5], [2, 3, 5], [3, 4, 5])</code> debe contener solo tres elementos.'
|
||||
- text: ' <code>sym([1, 2, 5], [2, 3, 5], [3, 4, 5])</code> debe contener solo tres elementos.'
|
||||
testString: 'assert.equal(sym([1, 2, 5], [2, 3, 5], [3, 4, 5]).length, 3, "<code>sym([1, 2, 5], [2, 3, 5], [3, 4, 5])</code> should contain only three elements.");'
|
||||
- text: ' <code>sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5])</code> debe devolver <code>[1, 4, 5]</code> .'
|
||||
- text: ' <code>sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5])</code> debe devolver <code>[1, 4, 5]</code> .'
|
||||
testString: 'assert.sameMembers(sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]), [1, 4, 5], "<code>sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5])</code> should return <code>[1, 4, 5]</code>.");'
|
||||
- text: ' <code>sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5])</code> debe contener solo tres elementos.'
|
||||
- text: ' <code>sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5])</code> debe contener solo tres elementos.'
|
||||
testString: 'assert.equal(sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5]).length, 3, "<code>sym([1, 1, 2, 5], [2, 2, 3, 5], [3, 4, 5, 5])</code> should contain only three elements.");'
|
||||
- text: ' <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3])</code> debe devolver <code>[2, 3, 4, 6, 7]</code> .
|
||||
- text: ' <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3])</code> debe devolver <code>[2, 3, 4, 6, 7]</code> .
|
||||
testString: 'assert.sameMembers(sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3]), [2, 3, 4, 6, 7], "<code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3])</code> should return <code>[2, 3, 4, 6, 7]</code>.");'
|
||||
- text: ' <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3])</code> debe contener solo cinco elementos.'
|
||||
- text: ' <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3])</code> debe contener solo cinco elementos.'
|
||||
testString: 'assert.equal(sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3]).length, 5, "<code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3])</code> should contain only five elements.");'
|
||||
- text: ' <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1])</code> debe devolver <code>[1, 2, 4, 5, 6, 7, 8, 9]</code> . '
|
||||
- text: ' <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1])</code> debe devolver <code>[1, 2, 4, 5, 6, 7, 8, 9]</code> . '
|
||||
testString: 'assert.sameMembers(sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1]), [1, 2, 4, 5, 6, 7, 8, 9], "<code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1])</code> should return <code>[1, 2, 4, 5, 6, 7, 8, 9]</code>.");'
|
||||
- text: ' <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1])</code> debe contener solo ocho elementos '.
|
||||
- text: ' <code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1])</code> debe contener solo ocho elementos '
|
||||
testString: 'assert.equal(sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1]).length, 8, "<code>sym([3, 3, 3, 2, 5], [2, 1, 5, 7], [3, 4, 6, 6], [1, 2, 3], [5, 3, 9, 8], [1])</code> should contain only eight elements.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,13 +6,13 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Compare y actualice el inventario almacenado en una matriz 2D con una segunda matriz 2D de una entrega nueva. Actualice las cantidades de artículos de inventario existentes actuales (en <code>arr1</code> ). Si no se puede encontrar un artículo, agregue el nuevo artículo y la cantidad en la matriz de inventario. La matriz de inventario devuelta debe estar ordenada alfabéticamente por artículo.
|
||||
Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
|
||||
<section id='description'>
|
||||
Compare y actualice el inventario almacenado en una matriz 2D con una segunda matriz 2D de una entrega nueva. Actualice las cantidades de artículos de inventario existentes actuales (en <code>arr1</code> ). Si no se puede encontrar un artículo, agregue el nuevo artículo y la cantidad en la matriz de inventario. La matriz de inventario devuelta debe estar ordenada alfabéticamente por artículo.
|
||||
Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -23,15 +23,15 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
tests:
|
||||
- text: La función <code>updateInventory</code> debería devolver una matriz.
|
||||
testString: 'assert.isArray(updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]]), "The function <code>updateInventory</code> should return an array.");'
|
||||
- text: ' <code>updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]])</code> debe devolver una matriz con una longitud de 6. '
|
||||
- text: ' <code>updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]])</code> debe devolver una matriz con una longitud de 6. '
|
||||
testString: 'assert.equal(updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]]).length, 6, "<code>updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]])</code> should return an array with a length of 6.");'
|
||||
- text: ' <code>updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]])</code> debe devolver <code>[[88, "Bowling Ball"], [2, "Dirty Sock"], [3, "Hair Pin"], [3, "Half-Eaten Apple"], [5, "Microphone"], [7, "Toothpaste"]]</code> . '
|
||||
- text: ' <code>updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]])</code> debe devolver <code>[[88, "Bowling Ball"], [2, "Dirty Sock"], [3, "Hair Pin"], [3, "Half-Eaten Apple"], [5, "Microphone"], [7, "Toothpaste"]]</code> . '
|
||||
testString: 'assert.deepEqual(updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]]), [[88, "Bowling Ball"], [2, "Dirty Sock"], [3, "Hair Pin"], [3, "Half-Eaten Apple"], [5, "Microphone"], [7, "Toothpaste"]], "<code>updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]])</code> should return <code>[[88, "Bowling Ball"], [2, "Dirty Sock"], [3, "Hair Pin"], [3, "Half-Eaten Apple"], [5, "Microphone"], [7, "Toothpaste"]]</code>.");'
|
||||
- text: ' <code>updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [])</code> debe devolver <code>[[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]]</code> . '
|
||||
- text: ' <code>updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [])</code> debe devolver <code>[[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]]</code> . '
|
||||
testString: 'assert.deepEqual(updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], []), [[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], "<code>updateInventory([[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]], [])</code> should return <code>[[21, "Bowling Ball"], [2, "Dirty Sock"], [1, "Hair Pin"], [5, "Microphone"]]</code>.");'
|
||||
- text: ' <code>updateInventory([], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]])</code> debe devolver <code>[[67, "Bowling Ball"], [2, "Hair Pin"], [3, "Half-Eaten Apple"], [7, "Toothpaste"]]</code> . '
|
||||
- text: ' <code>updateInventory([], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]])</code> debe devolver <code>[[67, "Bowling Ball"], [2, "Hair Pin"], [3, "Half-Eaten Apple"], [7, "Toothpaste"]]</code> . '
|
||||
testString: 'assert.deepEqual(updateInventory([], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]]), [[67, "Bowling Ball"], [2, "Hair Pin"], [3, "Half-Eaten Apple"], [7, "Toothpaste"]], "<code>updateInventory([], [[2, "Hair Pin"], [3, "Half-Eaten Apple"], [67, "Bowling Ball"], [7, "Toothpaste"]])</code> should return <code>[[67, "Bowling Ball"], [2, "Hair Pin"], [3, "Half-Eaten Apple"], [7, "Toothpaste"]]</code>.");'
|
||||
- text: ' <code>updateInventory([[0, "Bowling Ball"], [0, "Dirty Sock"], [0, "Hair Pin"], [0, "Microphone"]], [[1, "Hair Pin"], [1, "Half-Eaten Apple"], [1, "Bowling Ball"], [1, "Toothpaste"]])</code> debe devolver <code>[[1, "Bowling Ball"], [0, "Dirty Sock"], [1, "Hair Pin"], [1, "Half-Eaten Apple"], [0, "Microphone"], [1, "Toothpaste"]]</code> . '
|
||||
- text: ' <code>updateInventory([[0, "Bowling Ball"], [0, "Dirty Sock"], [0, "Hair Pin"], [0, "Microphone"]], [[1, "Hair Pin"], [1, "Half-Eaten Apple"], [1, "Bowling Ball"], [1, "Toothpaste"]])</code> debe devolver <code>[[1, "Bowling Ball"], [0, "Dirty Sock"], [1, "Hair Pin"], [1, "Half-Eaten Apple"], [0, "Microphone"], [1, "Toothpaste"]]</code> . '
|
||||
testString: 'assert.deepEqual(updateInventory([[0, "Bowling Ball"], [0, "Dirty Sock"], [0, "Hair Pin"], [0, "Microphone"]], [[1, "Hair Pin"], [1, "Half-Eaten Apple"], [1, "Bowling Ball"], [1, "Toothpaste"]]), [[1, "Bowling Ball"], [0, "Dirty Sock"], [1, "Hair Pin"], [1, "Half-Eaten Apple"], [0, "Microphone"], [1, "Toothpaste"]], "<code>updateInventory([[0, "Bowling Ball"], [0, "Dirty Sock"], [0, "Hair Pin"], [0, "Microphone"]], [[1, "Hair Pin"], [1, "Half-Eaten Apple"], [1, "Bowling Ball"], [1, "Toothpaste"]])</code> should return <code>[[1, "Bowling Ball"], [0, "Dirty Sock"], [1, "Hair Pin"], [1, "Half-Eaten Apple"], [0, "Microphone"], [1, "Toothpaste"]]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Dado una matriz <code>arr</code> , encuentre pares de elementos cuya suma sea igual al segundo argumento <code>arg</code> y devuelva la suma de sus índices.
|
||||
Puede usar varios pares que tengan los mismos elementos numéricos pero diferentes índices. Cada par debe usar los índices disponibles más bajos posibles. Una vez que se ha utilizado un elemento, no puede reutilizarse para emparejarse con otro elemento. Por ejemplo, por <code>pairwise([1, 1, 2], 3)</code> crea un par <code>[2, 1]</code> usando el 1 en el índice 0 en lugar del 1 en el índice 1, porque 0 + 2 <1 + 2.
|
||||
Por ejemplo, por <code>pairwise([7, 9, 11, 13, 15], 20)</code> devuelve <code>6</code> . Los pares que suman 20 son <code>[7, 13]</code> y <code>[9, 11]</code> . Luego podemos escribir la matriz con sus índices y valores.
|
||||
<table class="table"><tr><th> <strong>Índice</strong> </th><th> 0 </th><th> 1 </th><th> 2 </th><th> 3 </th><th> 4 </th></tr><tr><td> Valor </td><td> 7 </td><td> 9 </td><td> 11 </td><td> 13 </td><td> 15 </td></tr></table>
|
||||
A continuación tomaremos sus índices correspondientes y los añadiremos.
|
||||
7 + 13 = 20 → Índices 0 + 3 = 3 <br> 9 + 11 = 20 → Índices 1 + 2 = 3 <br> 3 + 3 = 6 → Volver <code>6</code>
|
||||
Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
|
||||
<section id='description'>
|
||||
Dado una matriz <code>arr</code> , encuentre pares de elementos cuya suma sea igual al segundo argumento <code>arg</code> y devuelva la suma de sus índices.
|
||||
Puede usar varios pares que tengan los mismos elementos numéricos pero diferentes índices. Cada par debe usar los índices disponibles más bajos posibles. Una vez que se ha utilizado un elemento, no puede reutilizarse para emparejarse con otro elemento. Por ejemplo, por <code>pairwise([1, 1, 2], 3)</code> crea un par <code>[2, 1]</code> usando el 1 en el índice 0 en lugar del 1 en el índice 1, porque 0 + 2 <1 + 2.
|
||||
Por ejemplo, por <code>pairwise([7, 9, 11, 13, 15], 20)</code> devuelve <code>6</code> . Los pares que suman 20 son <code>[7, 13]</code> y <code>[9, 11]</code> . Luego podemos escribir la matriz con sus índices y valores.
|
||||
<table class="table"><tr><th> <strong>Índice</strong> </th><th> 0 </th><th> 1 </th><th> 2 </th><th> 3 </th><th> 4 </th></tr><tr><td> Valor </td><td> 7 </td><td> 9 </td><td> 11 </td><td> 13 </td><td> 15 </td></tr></table>
|
||||
A continuación tomaremos sus índices correspondientes y los añadiremos.
|
||||
7 + 13 = 20 → Índices 0 + 3 = 3 <br> 9 + 11 = 20 → Índices 1 + 2 = 3 <br> 3 + 3 = 6 → Volver <code>6</code>
|
||||
Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-are-stuck/19514' target='_blank'>Read-Search-Ask</a> si te atascas. Trate de emparejar el programa. Escribe tu propio código.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -26,15 +26,15 @@ Recuerda usar <a href='http://forum.freecodecamp.org/t/how-to-get-help-when-you-
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>pairwise([1, 4, 2, 3, 0, 5], 7)</code> debe devolver 11.'
|
||||
- text: ' <code>pairwise([1, 4, 2, 3, 0, 5], 7)</code> debe devolver 11.'
|
||||
testString: 'assert.deepEqual(pairwise([1, 4, 2, 3, 0, 5], 7), 11, "<code>pairwise([1, 4, 2, 3, 0, 5], 7)</code> should return 11.");'
|
||||
- text: ' <code>pairwise([1, 3, 2, 4], 4)</code> debe devolver 1.'
|
||||
- text: ' <code>pairwise([1, 3, 2, 4], 4)</code> debe devolver 1.'
|
||||
testString: 'assert.deepEqual(pairwise([1, 3, 2, 4], 4), 1, "<code>pairwise([1, 3, 2, 4], 4)</code> should return 1.");'
|
||||
- text: ' <code>pairwise([1, 1, 1], 2)</code> debe devolver 1.'
|
||||
- text: ' <code>pairwise([1, 1, 1], 2)</code> debe devolver 1.'
|
||||
testString: 'assert.deepEqual(pairwise([1, 1, 1], 2), 1, "<code>pairwise([1, 1, 1], 2)</code> should return 1.");'
|
||||
- text: ' <code>pairwise([0, 0, 0, 0, 1, 1], 1)</code> debe devolver 10.'
|
||||
- text: ' <code>pairwise([0, 0, 0, 0, 1, 1], 1)</code> debe devolver 10.'
|
||||
testString: 'assert.deepEqual(pairwise([0, 0, 0, 0, 1, 1], 1), 10, "<code>pairwise([0, 0, 0, 0, 1, 1], 1)</code> should return 10.");'
|
||||
- text: ' <code>pairwise([], 100)</code> debe devolver 0.'
|
||||
- text: ' <code>pairwise([], 100)</code> debe devolver 0.'
|
||||
testString: 'assert.deepEqual(pairwise([], 100), 0, "<code>pairwise([], 100)</code> should return 0.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,22 +6,22 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Hasta ahora, hemos aprendido diferentes formas de crear representaciones de gráficos. ¿Ahora que? Una pregunta natural que se debe tener es ¿cuáles son las distancias entre dos nodos en el gráfico? Introduzca los <dfn>algoritmos de recorrido del gráfico</dfn> .
|
||||
<dfn>algoritmos de recorrido</dfn> son algoritmos para atravesar o visitar los nodos en un gráfico. Un tipo de algoritmo de recorrido es el primer algoritmo de búsqueda.
|
||||
Este algoritmo comienza en un nodo, primero visita a todos sus vecinos que están a un borde de distancia, luego continúa visitando a cada uno de sus vecinos.
|
||||
Visualmente, esto es lo que hace el algoritmo.
|
||||
<img class='img-responsive' src='https://camo.githubusercontent.com/2f57e6239884a1a03402912f13c49555dec76d06/68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f342f34362f416e696d617465645f4246532e676966'>
|
||||
Para implementar este algoritmo, deberá ingresar una estructura de gráfico y un nodo en el que desee comenzar.
|
||||
Primero, querrá estar al tanto de las distancias desde el nodo de inicio. Esto querrá comenzar todas sus distancias, inicialmente un número grande, como <code>Infinity</code> . Esto proporciona una referencia para el caso en el que no se puede acceder a un nodo desde su nodo de inicio.
|
||||
A continuación, querrá ir desde el nodo de inicio a sus vecinos. Estos vecinos están a un borde de distancia y en este punto debes agregar una unidad de distancia a las distancias que estás siguiendo.
|
||||
último, la cola es una estructura de datos importante que ayudará a implementar el primer algoritmo de búsqueda. Esta es una matriz donde puede agregar elementos a un extremo y eliminar elementos del otro extremo. Esto también se conoce como estructura de datos <dfn>FIFO</dfn> o <dfn>primero en entrar, primero en salir</dfn> .
|
||||
<section id='description'>
|
||||
Hasta ahora, hemos aprendido diferentes formas de crear representaciones de gráficos. ¿Ahora que? Una pregunta natural que se debe tener es ¿cuáles son las distancias entre dos nodos en el gráfico? Introduzca los <dfn>algoritmos de recorrido del gráfico</dfn> .
|
||||
<dfn>algoritmos de recorrido</dfn> son algoritmos para atravesar o visitar los nodos en un gráfico. Un tipo de algoritmo de recorrido es el primer algoritmo de búsqueda.
|
||||
Este algoritmo comienza en un nodo, primero visita a todos sus vecinos que están a un borde de distancia, luego continúa visitando a cada uno de sus vecinos.
|
||||
Visualmente, esto es lo que hace el algoritmo.
|
||||
<img class='img-responsive' src='https://camo.githubusercontent.com/2f57e6239884a1a03402912f13c49555dec76d06/68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f342f34362f416e696d617465645f4246532e676966'>
|
||||
Para implementar este algoritmo, deberá ingresar una estructura de gráfico y un nodo en el que desee comenzar.
|
||||
Primero, querrá estar al tanto de las distancias desde el nodo de inicio. Esto querrá comenzar todas sus distancias, inicialmente un número grande, como <code>Infinity</code> . Esto proporciona una referencia para el caso en el que no se puede acceder a un nodo desde su nodo de inicio.
|
||||
A continuación, querrá ir desde el nodo de inicio a sus vecinos. Estos vecinos están a un borde de distancia y en este punto debes agregar una unidad de distancia a las distancias que estás siguiendo.
|
||||
último, la cola es una estructura de datos importante que ayudará a implementar el primer algoritmo de búsqueda. Esta es una matriz donde puede agregar elementos a un extremo y eliminar elementos del otro extremo. Esto también se conoce como estructura de datos <dfn>FIFO</dfn> o <dfn>primero en entrar, primero en salir</dfn> .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Escriba una función <code>bfs()</code> que tome un gráfico de matriz de adyacencia (una matriz bidimensional) y una raíz de etiqueta de nodo como parámetros. La etiqueta del nodo solo será el valor entero del nodo entre <code>0</code> y <code>n - 1</code> , donde <code>n</code> es el número total de nodos en el gráfico.
|
||||
Su función dará salida a un objeto JavaScript pares de clave-valor con el nodo y su distancia desde la raíz. Si no se pudo alcanzar el nodo, debería tener una distancia de <code>Infinity</code> .
|
||||
<section id='instructions'>
|
||||
Escriba una función <code>bfs()</code> que tome un gráfico de matriz de adyacencia (una matriz bidimensional) y una raíz de etiqueta de nodo como parámetros. La etiqueta del nodo solo será el valor entero del nodo entre <code>0</code> y <code>n - 1</code> , donde <code>n</code> es el número total de nodos en el gráfico.
|
||||
Su función dará salida a un objeto JavaScript pares de clave-valor con el nodo y su distancia desde la raíz. Si no se pudo alcanzar el nodo, debería tener una distancia de <code>Infinity</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -29,13 +29,13 @@ Su función dará salida a un objeto JavaScript pares de clave-valor con el nodo
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>1</code> debe devolver <code>{0: 1, 1: 0, 2: 1, 3: 2}</code> '
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>1</code> debe devolver <code>{0: 1, 1: 0, 2: 1, 3: 2}</code> '
|
||||
testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]; var results = bfs(graph, 1); return isEquivalent(results, {0: 1, 1: 0, 2: 1, 3: 2})})(), "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>1</code> should return <code>{0: 1, 1: 0, 2: 1, 3: 2}</code>");'
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> con un nodo de inicio de <code>1</code> debería devolver <code>{0: 1, 1: 0, 2: 1, 3: Infinity}</code> '
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> con un nodo de inicio de <code>1</code> debería devolver <code>{0: 1, 1: 0, 2: 1, 3: Infinity}</code> '
|
||||
testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]; var results = bfs(graph, 1); return isEquivalent(results, {0: 1, 1: 0, 2: 1, 3: Infinity})})(), "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> with a start node of <code>1</code> should return <code>{0: 1, 1: 0, 2: 1, 3: Infinity}</code>");'
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>0</code> debe devolver <code>{0: 0, 1: 1, 2: 2, 3: 3}</code> '
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>0</code> debe devolver <code>{0: 0, 1: 1, 2: 2, 3: 3}</code> '
|
||||
testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]; var results = bfs(graph, 0); return isEquivalent(results, {0: 0, 1: 1, 2: 2, 3: 3})})(), "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>0</code> should return <code>{0: 0, 1: 1, 2: 2, 3: 3}</code>");'
|
||||
- text: 'El gráfico de entrada <code>[[0, 1], [1, 0]]</code> con un nodo de inicio de <code>0</code> debe devolver <code>{0: 0, 1: 1}</code> '
|
||||
- text: 'El gráfico de entrada <code>[[0, 1], [1, 0]]</code> con un nodo de inicio de <code>0</code> debe devolver <code>{0: 0, 1: 1}</code> '
|
||||
testString: 'assert((function() { var graph = [[0, 1], [1, 0]]; var results = bfs(graph, 0); return isEquivalent(results, {0: 0, 1: 1})})(), "The input graph <code>[[0, 1], [1, 0]]</code> with a start node of <code>0</code> should return <code>{0: 0, 1: 1}</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,23 +6,23 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Los próximos desafíos cubrirán mapas y tablas hash. Los mapas son estructuras de datos que almacenan pares clave-valor. En JavaScript, estos están disponibles para nosotros como objetos. Los mapas proporcionan una búsqueda rápida de elementos almacenados en función de valores clave y son estructuras de datos muy comunes y útiles.
|
||||
Instrucciones: Hagamos algo de práctica creando nuestro propio mapa. Debido a que los objetos de JavaScript proporcionan una estructura de mapa mucho más eficiente que cualquier otra que podamos escribir aquí, esto está pensado principalmente como un ejercicio de aprendizaje. Sin embargo, los objetos de JavaScript solo nos proporcionan ciertas operaciones. ¿Y si quisiéramos definir operaciones personalizadas?
|
||||
Utilice el objeto <code>Map</code> que se proporciona aquí como una envoltura alrededor de un <code>object</code> JavaScript. Cree los siguientes métodos y operaciones en el objeto Mapa:
|
||||
<ul>
|
||||
<li> <code>add</code> acepta una <code>key, value</code> par de <code>key, value</code> para agregar al mapa. </li>
|
||||
<li> <code>remove</code> acepta una clave y elimina la <code>key, value</code> asociada <code>key, value</code> par de <code>key, value</code> </li>
|
||||
<li> <code>get</code> acepta una <code>key</code> y devuelve el <code>value</code> almacenado </li>
|
||||
<li> <code>has</code> acepta una <code>key</code> y devuelve <dfn>verdadero</dfn> si existe la clave o <dfn>falso</dfn> si no lo hace. </li>
|
||||
<li> <code>values</code> devuelve una matriz de todos los valores en el mapa </li>
|
||||
<li> <code>size</code> devuelve el número de elementos en el mapa </li>
|
||||
<li> <code>clear</code> vacía el mapa </li>
|
||||
</ul>
|
||||
<section id='description'>
|
||||
Los próximos desafíos cubrirán mapas y tablas hash. Los mapas son estructuras de datos que almacenan pares clave-valor. En JavaScript, estos están disponibles para nosotros como objetos. Los mapas proporcionan una búsqueda rápida de elementos almacenados en función de valores clave y son estructuras de datos muy comunes y útiles.
|
||||
Instrucciones: Hagamos algo de práctica creando nuestro propio mapa. Debido a que los objetos de JavaScript proporcionan una estructura de mapa mucho más eficiente que cualquier otra que podamos escribir aquí, esto está pensado principalmente como un ejercicio de aprendizaje. Sin embargo, los objetos de JavaScript solo nos proporcionan ciertas operaciones. ¿Y si quisiéramos definir operaciones personalizadas?
|
||||
Utilice el objeto <code>Map</code> que se proporciona aquí como una envoltura alrededor de un <code>object</code> JavaScript. Cree los siguientes métodos y operaciones en el objeto Mapa:
|
||||
<ul>
|
||||
<li> <code>add</code> acepta una <code>key, value</code> par de <code>key, value</code> para agregar al mapa. </li>
|
||||
<li> <code>remove</code> acepta una clave y elimina la <code>key, value</code> asociada <code>key, value</code> par de <code>key, value</code> </li>
|
||||
<li> <code>get</code> acepta una <code>key</code> y devuelve el <code>value</code> almacenado </li>
|
||||
<li> <code>has</code> acepta una <code>key</code> y devuelve <dfn>verdadero</dfn> si existe la clave o <dfn>falso</dfn> si no lo hace. </li>
|
||||
<li> <code>values</code> devuelve una matriz de todos los valores en el mapa </li>
|
||||
<li> <code>size</code> devuelve el número de elementos en el mapa </li>
|
||||
<li> <code>clear</code> vacía el mapa </li>
|
||||
</ul>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -33,7 +33,7 @@ Utilice el objeto <code>Map</code> que se proporciona aquí como una envoltura a
|
||||
tests:
|
||||
- text: La estructura de datos del mapa existe.
|
||||
testString: 'assert((function() { var test = false; if (typeof Map !== "undefined") { test = new Map() }; return (typeof test == "object")})(), "The Map data structure exists.");'
|
||||
- text: 'El objeto Mapa tiene los siguientes métodos: agregar, eliminar, obtener, tiene, valores, borrar y tamaño'.
|
||||
- text: 'El objeto Mapa tiene los siguientes métodos: agregar, eliminar, obtener, tiene, valores, borrar y tamaño.'
|
||||
testString: 'assert((function() { var test = false; if (typeof Map !== "undefined") { test = new Map() }; return (typeof test.add == "function" && typeof test.remove == "function" && typeof test.get == "function" && typeof test.has == "function" && typeof test.values == "function" && typeof test.clear == "function" && typeof test.size == "function")})(), "The Map object has the following methods: add, remove, get, has, values, clear, and size.");'
|
||||
- text: El método add agrega elementos al mapa.
|
||||
testString: 'assert((function() { var test = false; if (typeof Map !== "undefined") { test = new Map() }; test.add(5,6); test.add(2,3); test.add(2,5); return (test.size() == 2)})(), "The add method adds items to the map.");'
|
||||
|
||||
@@ -6,23 +6,23 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora que ha trabajado con ES5, va a realizar algo similar en ES6. Esto será considerablemente más fácil. ES6 contiene una estructura de datos incorporada <code>Set</code> muchas de las operaciones que ha escrito a mano se incluyen ahora para usted. Echemos un vistazo:
|
||||
Para crear un nuevo conjunto vacío:
|
||||
<code>var set = new Set();</code>
|
||||
Puede crear un conjunto con un valor:
|
||||
<code>var set = new Set(1);</code>
|
||||
Puede crear un conjunto con una matriz:
|
||||
<code>var set = new Set([1, 2, 3]);</code>
|
||||
Una vez que haya creado un conjunto, puede agregar los valores que desee utilizando el método de <code>add</code> :
|
||||
<blockquote>var set = new Set([1, 2, 3]);<br>set.add([4, 5, 6]);</blockquote>
|
||||
Como recordatorio, un conjunto es una estructura de datos que no puede contener valores duplicados:
|
||||
<blockquote>var set = new Set([1, 2, 3, 1, 2, 3]);<br>// set contains [1, 2, 3] only</blockquote>
|
||||
<section id='description'>
|
||||
Ahora que ha trabajado con ES5, va a realizar algo similar en ES6. Esto será considerablemente más fácil. ES6 contiene una estructura de datos incorporada <code>Set</code> muchas de las operaciones que ha escrito a mano se incluyen ahora para usted. Echemos un vistazo:
|
||||
Para crear un nuevo conjunto vacío:
|
||||
<code>var set = new Set();</code>
|
||||
Puede crear un conjunto con un valor:
|
||||
<code>var set = new Set(1);</code>
|
||||
Puede crear un conjunto con una matriz:
|
||||
<code>var set = new Set([1, 2, 3]);</code>
|
||||
Una vez que haya creado un conjunto, puede agregar los valores que desee utilizando el método de <code>add</code> :
|
||||
<blockquote>var set = new Set([1, 2, 3]);<br>set.add([4, 5, 6]);</blockquote>
|
||||
Como recordatorio, un conjunto es una estructura de datos que no puede contener valores duplicados:
|
||||
<blockquote>var set = new Set([1, 2, 3, 1, 2, 3]);<br>// set contains [1, 2, 3] only</blockquote>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Para este ejercicio, devuelva un conjunto con los siguientes valores: <code>1, 2, 3, 'Taco', 'Cat', 'Awesome'</code>
|
||||
<section id='instructions'>
|
||||
Para este ejercicio, devuelva un conjunto con los siguientes valores: <code>1, 2, 3, 'Taco', 'Cat', 'Awesome'</code>
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -30,7 +30,7 @@ Para este ejercicio, devuelva un conjunto con los siguientes valores: <code>1, 2
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Tu <code>Set</code> solo debe contener los valores <code>1, 2, 3, Taco, Cat, Awesome</code> '.
|
||||
- text: 'Tu <code>Set</code> solo debe contener los valores <code>1, 2, 3, Taco, Cat, Awesome</code> '
|
||||
testString: 'assert(function(){var test = checkSet(); return (test.size == 6) && test.has(1) && test.has(2) && test.has(3) && test.has("Taco") && test.has("Cat") && test.has("Awesome");}, "Your <code>Set</code> should only contain the values <code>1, 2, 3, Taco, Cat, Awesome</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Este es el primero de los tres desafíos en los que implementaremos una operación más difícil en los árboles de búsqueda binarios: eliminación. La eliminación es difícil porque la eliminación de nodos rompe los enlaces en el árbol. Estos enlaces deben restablecerse cuidadosamente para garantizar que se mantenga la estructura del árbol binario. Para algunas eliminaciones, esto significa que el árbol debe ser reorganizado. En general, encontrará uno de los tres casos cuando intente eliminar un nodo:
|
||||
Nodo hoja: el objetivo que se eliminará tiene cero hijos.
|
||||
Un hijo: el objetivo que se eliminará solo tiene un hijo.
|
||||
Dos hijos: El objetivo a eliminar tiene dos nodos hijos.
|
||||
Eliminar un nodo hoja es fácil, simplemente lo eliminamos. Eliminar un nodo con un hijo también es relativamente fácil, simplemente lo eliminamos y vinculamos su padre al hijo del nodo que eliminamos. Sin embargo, la eliminación de un nodo con dos hijos es más difícil, ya que esto crea dos nodos hijos que deben volver a conectarse al árbol padre. Veremos cómo lidiar con este caso en el tercer desafío. Además, debe tener en cuenta algunos casos de ventaja al manejar la eliminación. ¿Qué pasa si el árbol está vacío? ¿Qué pasa si el nodo a eliminar es el nodo raíz? ¿Y si solo hay dos elementos en el árbol? Por ahora, vamos a manejar el primer caso donde eliminamos un nodo de hoja.
|
||||
Instrucciones: Crea un método en nuestro árbol binario llamado <code>remove</code> . Construiremos la lógica para nuestra operación de eliminación aquí. Primero, querrá crear una función dentro de eliminar que encuentre el nodo que intentamos eliminar en el árbol actual. Si el nodo no está presente en el árbol, <code>remove</code> debe devolver <code>null</code> . Ahora, si el nodo de destino es un nodo de hoja sin hijos, entonces la referencia principal debe establecerse en <code>null</code> . Esto elimina efectivamente el nodo del árbol. Para hacer esto, también deberá hacer un seguimiento del padre del nodo que estamos intentando eliminar. También será útil para crear una forma de realizar un seguimiento del número de hijos que tiene el nodo de destino, ya que esto determinará en qué caso se encuentra nuestra eliminación.
|
||||
Manejaremos el segundo y tercer caso en los próximos desafíos. ¡Buena suerte!
|
||||
<section id='description'>
|
||||
Este es el primero de los tres desafíos en los que implementaremos una operación más difícil en los árboles de búsqueda binarios: eliminación. La eliminación es difícil porque la eliminación de nodos rompe los enlaces en el árbol. Estos enlaces deben restablecerse cuidadosamente para garantizar que se mantenga la estructura del árbol binario. Para algunas eliminaciones, esto significa que el árbol debe ser reorganizado. En general, encontrará uno de los tres casos cuando intente eliminar un nodo:
|
||||
Nodo hoja: el objetivo que se eliminará tiene cero hijos.
|
||||
Un hijo: el objetivo que se eliminará solo tiene un hijo.
|
||||
Dos hijos: El objetivo a eliminar tiene dos nodos hijos.
|
||||
Eliminar un nodo hoja es fácil, simplemente lo eliminamos. Eliminar un nodo con un hijo también es relativamente fácil, simplemente lo eliminamos y vinculamos su padre al hijo del nodo que eliminamos. Sin embargo, la eliminación de un nodo con dos hijos es más difícil, ya que esto crea dos nodos hijos que deben volver a conectarse al árbol padre. Veremos cómo lidiar con este caso en el tercer desafío. Además, debe tener en cuenta algunos casos de ventaja al manejar la eliminación. ¿Qué pasa si el árbol está vacío? ¿Qué pasa si el nodo a eliminar es el nodo raíz? ¿Y si solo hay dos elementos en el árbol? Por ahora, vamos a manejar el primer caso donde eliminamos un nodo de hoja.
|
||||
Instrucciones: Crea un método en nuestro árbol binario llamado <code>remove</code> . Construiremos la lógica para nuestra operación de eliminación aquí. Primero, querrá crear una función dentro de eliminar que encuentre el nodo que intentamos eliminar en el árbol actual. Si el nodo no está presente en el árbol, <code>remove</code> debe devolver <code>null</code> . Ahora, si el nodo de destino es un nodo de hoja sin hijos, entonces la referencia principal debe establecerse en <code>null</code> . Esto elimina efectivamente el nodo del árbol. Para hacer esto, también deberá hacer un seguimiento del padre del nodo que estamos intentando eliminar. También será útil para crear una forma de realizar un seguimiento del número de hijos que tiene el nodo de destino, ya que esto determinará en qué caso se encuentra nuestra eliminación.
|
||||
Manejaremos el segundo y tercer caso en los próximos desafíos. ¡Buena suerte!
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -32,7 +32,7 @@ tests:
|
||||
testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; return (typeof test.remove == "function")})(), "The binary search tree has a method called <code>remove</code>.");'
|
||||
- text: Intentar eliminar un elemento que no existe devuelve <code>null</code> .
|
||||
testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; if (typeof test.remove !== "function") { return false; }; return (test.remove(100) == null); })(), "Trying to remove an element that does not exist returns <code>null</code>.");'
|
||||
- text: 'Si el nodo raíz no tiene hijos, al eliminarlo, se establece la raíz en <code>null</code> '.
|
||||
- text: 'Si el nodo raíz no tiene hijos, al eliminarlo, se establece la raíz en <code>null</code> '
|
||||
testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; if (typeof test.remove !== "function") { return false; }; test.add(500); test.remove(500); return (test.inorder() == null); })(), "If the root node has no children, deleting it sets the root to <code>null</code>.");'
|
||||
- text: El método de <code>remove</code> elimina los nodos de hoja del árbol.
|
||||
testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; if (typeof test.remove !== "function") { return false; }; test.add(5); test.add(3); test.add(7); test.add(6); test.add(10); test.add(12); test.remove(3); test.remove(12); test.remove(10); return (test.inorder().join("") == "567"); })(), "The <code>remove</code> method removes leaf nodes from the tree");'
|
||||
|
||||
@@ -6,13 +6,13 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora que podemos eliminar los nodos de hoja, pasemos al segundo caso: eliminar un nodo con un hijo. Para este caso, digamos que tenemos un árbol con los siguientes nodos 1 - 2 - 3 donde 1 es la raíz. Para eliminar 2, simplemente necesitamos hacer la referencia correcta en 1 punto a 3. De manera más general, para eliminar un nodo con un solo hijo, hacemos que la referencia principal de ese nodo sea el siguiente nodo del árbol.
|
||||
Instrucciones: Hemos proporcionado algún código en nuestro método de <code>remove</code> que cumple las tareas del último desafío. Encontramos el objetivo a eliminar y su padre y definimos la cantidad de hijos que tiene el nodo objetivo. Agreguemos el siguiente caso aquí para los nodos de destino con un solo hijo. Aquí, tendremos que determinar si el único hijo es una rama izquierda o derecha en el árbol y luego establecer la referencia correcta en el padre para apuntar a este nodo. Además, consideremos el caso en el que el destino es el nodo raíz (esto significa que el nodo principal será <code>null</code> ). Siéntase libre de reemplazar todo el código de inicio con el suyo, siempre y cuando pase las pruebas.
|
||||
<section id='description'>
|
||||
Ahora que podemos eliminar los nodos de hoja, pasemos al segundo caso: eliminar un nodo con un hijo. Para este caso, digamos que tenemos un árbol con los siguientes nodos 1 - 2 - 3 donde 1 es la raíz. Para eliminar 2, simplemente necesitamos hacer la referencia correcta en 1 punto a 3. De manera más general, para eliminar un nodo con un solo hijo, hacemos que la referencia principal de ese nodo sea el siguiente nodo del árbol.
|
||||
Instrucciones: Hemos proporcionado algún código en nuestro método de <code>remove</code> que cumple las tareas del último desafío. Encontramos el objetivo a eliminar y su padre y definimos la cantidad de hijos que tiene el nodo objetivo. Agreguemos el siguiente caso aquí para los nodos de destino con un solo hijo. Aquí, tendremos que determinar si el único hijo es una rama izquierda o derecha en el árbol y luego establecer la referencia correcta en el padre para apuntar a este nodo. Además, consideremos el caso en el que el destino es el nodo raíz (esto significa que el nodo principal será <code>null</code> ). Siéntase libre de reemplazar todo el código de inicio con el suyo, siempre y cuando pase las pruebas.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -27,7 +27,7 @@ tests:
|
||||
testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; return (typeof test.remove == "function")})(), "The binary search tree has a method called <code>remove</code>.");'
|
||||
- text: Intentar eliminar un elemento que no existe devuelve <code>null</code> .
|
||||
testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; if (typeof test.remove !== "function") { return false; }; return (test.remove(100) == null); })(), "Trying to remove an element that does not exist returns <code>null</code>.");'
|
||||
- text: 'Si el nodo raíz no tiene hijos, al eliminarlo, se establece la raíz en <code>null</code> '.
|
||||
- text: 'Si el nodo raíz no tiene hijos, al eliminarlo, se establece la raíz en <code>null</code> '
|
||||
testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; if (typeof test.remove !== "function") { return false; }; test.add(500); test.remove(500); return (test.inorder() == null); })(), "If the root node has no children, deleting it sets the root to <code>null</code>.");'
|
||||
- text: El método de <code>remove</code> elimina los nodos de hoja del árbol.
|
||||
testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; if (typeof test.remove !== "function") { return false; }; test.add(5); test.add(3); test.add(7); test.add(6); test.add(10); test.add(12); test.remove(3); test.remove(12); test.remove(10); return (test.inorder().join("") == "567"); })(), "The <code>remove</code> method removes leaf nodes from the tree");'
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Eliminar los nodos que tienen dos hijos es el caso más difícil de implementar. La eliminación de un nodo como este produce dos subárboles que ya no están conectados a la estructura de árbol original. ¿Cómo podemos reconectarlos? Un método es encontrar el valor más pequeño en el subárbol derecho del nodo de destino y reemplazar el nodo de destino con este valor. Seleccionar el reemplazo de esta manera asegura que sea mayor que cada nodo en el subárbol izquierdo, se convierte en el nuevo padre, pero también en menos que cada nodo en el subárbol derecho se convierte en el nuevo padre.
|
||||
Una vez que se realiza este reemplazo, el nodo de reemplazo debe eliminarse del subárbol derecho. Incluso esta operación es complicada porque el reemplazo puede ser una hoja o puede ser el padre de un subárbol derecho. Si es una hoja debemos eliminar la referencia de su padre. De lo contrario, debe ser el hijo derecho del objetivo. En este caso, debemos reemplazar el valor objetivo con el valor de reemplazo y hacer que la referencia objetivo sea el hijo derecho del reemplazo.
|
||||
Instrucciones: Terminemos nuestro método de <code>remove</code> manejando el tercer caso. Hemos proporcionado un código nuevo para los dos primeros casos. Agregue un poco de código ahora para manejar los nodos de destino con dos hijos. ¿Algún caso de borde a tener en cuenta? ¿Qué pasa si el árbol tiene sólo tres nodos? Una vez que haya terminado, esto completará nuestra operación de eliminación de árboles de búsqueda binarios. Buen trabajo, este es un problema bastante difícil!
|
||||
<section id='description'>
|
||||
Eliminar los nodos que tienen dos hijos es el caso más difícil de implementar. La eliminación de un nodo como este produce dos subárboles que ya no están conectados a la estructura de árbol original. ¿Cómo podemos reconectarlos? Un método es encontrar el valor más pequeño en el subárbol derecho del nodo de destino y reemplazar el nodo de destino con este valor. Seleccionar el reemplazo de esta manera asegura que sea mayor que cada nodo en el subárbol izquierdo, se convierte en el nuevo padre, pero también en menos que cada nodo en el subárbol derecho se convierte en el nuevo padre.
|
||||
Una vez que se realiza este reemplazo, el nodo de reemplazo debe eliminarse del subárbol derecho. Incluso esta operación es complicada porque el reemplazo puede ser una hoja o puede ser el padre de un subárbol derecho. Si es una hoja debemos eliminar la referencia de su padre. De lo contrario, debe ser el hijo derecho del objetivo. En este caso, debemos reemplazar el valor objetivo con el valor de reemplazo y hacer que la referencia objetivo sea el hijo derecho del reemplazo.
|
||||
Instrucciones: Terminemos nuestro método de <code>remove</code> manejando el tercer caso. Hemos proporcionado un código nuevo para los dos primeros casos. Agregue un poco de código ahora para manejar los nodos de destino con dos hijos. ¿Algún caso de borde a tener en cuenta? ¿Qué pasa si el árbol tiene sólo tres nodos? Una vez que haya terminado, esto completará nuestra operación de eliminación de árboles de búsqueda binarios. Buen trabajo, este es un problema bastante difícil!
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -28,7 +28,7 @@ tests:
|
||||
testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; return (typeof test.remove == "function")})(), "The binary search tree has a method called <code>remove</code>.");'
|
||||
- text: Intentar eliminar un elemento que no existe devuelve <code>null</code> .
|
||||
testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; return (typeof test.remove == "function") ? (test.remove(100) == null) : false})(), "Trying to remove an element that does not exist returns <code>null</code>.");'
|
||||
- text: 'Si el nodo raíz no tiene hijos, al eliminarlo, se establece la raíz en <code>null</code> '.
|
||||
- text: 'Si el nodo raíz no tiene hijos, al eliminarlo, se establece la raíz en <code>null</code> '
|
||||
testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; test.add(500); test.remove(500); return (typeof test.remove == "function") ? (test.inorder() == null) : false})(), "If the root node has no children, deleting it sets the root to <code>null</code>.");'
|
||||
- text: El método de <code>remove</code> elimina los nodos de hoja del árbol.
|
||||
testString: 'assert((function() { var test = false; if (typeof BinarySearchTree !== "undefined") { test = new BinarySearchTree() } else { return false; }; test.add(5); test.add(3); test.add(7); test.add(6); test.add(10); test.add(12); test.remove(3); test.remove(12); test.remove(10); return (typeof test.remove == "function") ? (test.inorder().join("") == "567") : false})(), "The <code>remove</code> method removes leaf nodes from the tree");'
|
||||
|
||||
@@ -6,19 +6,19 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
igual que <dfn>en la búsqueda de amplitud en primer lugar</dfn> , aquí aprenderemos sobre otro algoritmo de recorrido de gráficos llamado <dfn>búsqueda de primero en profundidad</dfn> .
|
||||
Mientras que la búsqueda en amplitud busca las longitudes de borde incrementales lejos del nodo de origen, la <dfn>búsqueda en profundidad</dfn> primero recorre un camino de bordes lo más lejos posible.
|
||||
Una vez que llega a un extremo de una ruta, la búsqueda volverá al último nodo con una ruta de borde no visitada y continuará la búsqueda.
|
||||
Visualmente, esto es lo que hace el algoritmo donde el nodo superior es el punto de inicio de la búsqueda.
|
||||
<img class='img-responsive' src='https://camo.githubusercontent.com/aaad9e39961daf34d967c616edeb50abf3bf1235/68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f372f37662f44657074682d46697273742d5365617263682e676966'>
|
||||
Una salida simple de este algoritmo es una lista de nodos a los que se puede acceder desde un nodo determinado. Entonces, al implementar este algoritmo, deberá realizar un seguimiento de los nodos que visita.
|
||||
<section id='description'>
|
||||
igual que <dfn>en la búsqueda de amplitud en primer lugar</dfn> , aquí aprenderemos sobre otro algoritmo de recorrido de gráficos llamado <dfn>búsqueda de primero en profundidad</dfn> .
|
||||
Mientras que la búsqueda en amplitud busca las longitudes de borde incrementales lejos del nodo de origen, la <dfn>búsqueda en profundidad</dfn> primero recorre un camino de bordes lo más lejos posible.
|
||||
Una vez que llega a un extremo de una ruta, la búsqueda volverá al último nodo con una ruta de borde no visitada y continuará la búsqueda.
|
||||
Visualmente, esto es lo que hace el algoritmo donde el nodo superior es el punto de inicio de la búsqueda.
|
||||
<img class='img-responsive' src='https://camo.githubusercontent.com/aaad9e39961daf34d967c616edeb50abf3bf1235/68747470733a2f2f75706c6f61642e77696b696d656469612e6f72672f77696b6970656469612f636f6d6d6f6e732f372f37662f44657074682d46697273742d5365617263682e676966'>
|
||||
Una salida simple de este algoritmo es una lista de nodos a los que se puede acceder desde un nodo determinado. Entonces, al implementar este algoritmo, deberá realizar un seguimiento de los nodos que visita.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Escriba una función <code>dfs()</code> que tome un <code>graph</code> matriz de adyacencia no <code>graph</code> y una <code>root</code> etiqueta de nodo como parámetros. La etiqueta del nodo solo será el valor numérico del nodo entre <code>0</code> y <code>n - 1</code> , donde <code>n</code> es el número total de nodos en el gráfico.
|
||||
Su función debe generar una matriz de todos los nodos accesibles desde la <code>root</code> .
|
||||
<section id='instructions'>
|
||||
Escriba una función <code>dfs()</code> que tome un <code>graph</code> matriz de adyacencia no <code>graph</code> y una <code>root</code> etiqueta de nodo como parámetros. La etiqueta del nodo solo será el valor numérico del nodo entre <code>0</code> y <code>n - 1</code> , donde <code>n</code> es el número total de nodos en el gráfico.
|
||||
Su función debe generar una matriz de todos los nodos accesibles desde la <code>root</code> .
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -26,21 +26,21 @@ Su función debe generar una matriz de todos los nodos accesibles desde la <code
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>1</code> debería devolver una matriz con <code>0</code> , <code>1</code> , <code>2</code> y <code>3</code> '.
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>1</code> debería devolver una matriz con <code>0</code> , <code>1</code> , <code>2</code> y <code>3</code> '
|
||||
testString: 'assert.sameMembers((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]; return dfs(graph, 1);})(), [0, 1, 2, 3], "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>1</code> should return an array with <code>0</code>, <code>1</code>, <code>2</code>, and <code>3</code>.");'
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>1</code> debería devolver una matriz con cuatro elementos '.
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>1</code> debería devolver una matriz con cuatro elementos '
|
||||
testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]; return dfs(graph, 1);})().length === 4, "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>1</code> should return an array with four elements.");'
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con <code>3</code> '.
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con <code>3</code> '
|
||||
testString: 'assert.sameMembers((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]; return dfs(graph, 3);})(), [3], "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> with a start node of <code>3</code> should return an array with <code>3</code>.");'
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con un elemento '.
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con un elemento '
|
||||
testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]; return dfs(graph, 3);})().length === 1, "The input graph <code>[[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]]</code> with a start node of <code>3</code> should return an array with one element.");'
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con <code>2</code> y <code>3</code> '.
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con <code>2</code> y <code>3</code> '
|
||||
testString: 'assert.sameMembers((function() { var graph = [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]; return dfs(graph, 3);})(), [2, 3], "The input graph <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>3</code> should return an array with <code>2</code> and <code>3</code>.");'
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con dos elementos '.
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>3</code> debería devolver una matriz con dos elementos '
|
||||
testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]; return dfs(graph, 3);})().length === 2, "The input graph <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>3</code> should return an array with two elements.");'
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>0</code> debería devolver una matriz con <code>0</code> y <code>1</code> '.
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>0</code> debería devolver una matriz con <code>0</code> y <code>1</code> '
|
||||
testString: 'assert.sameMembers((function() { var graph = [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]; return dfs(graph, 0);})(), [0, 1], "The input graph <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>0</code> should return an array with <code>0</code> and <code>1</code>.");'
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>0</code> debería devolver una matriz con dos elementos '.
|
||||
- text: 'El gráfico de entrada <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> con un nodo de inicio de <code>0</code> debería devolver una matriz con dos elementos '
|
||||
testString: 'assert((function() { var graph = [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]; return dfs(graph, 0);})().length === 2, "The input graph <code>[[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]]</code> with a start node of <code>0</code> should return an array with two elements.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,13 +6,13 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En este ejercicio vamos a realizar una prueba de subconjunto en 2 conjuntos de datos. Crearemos un método en nuestra estructura de datos <code>Set</code> llamada <code>subset</code> . Esto comparará el primer conjunto, contra el segundo y si el primer conjunto está completamente contenido dentro del Segundo, devolverá verdadero.
|
||||
Por ejemplo, si <code>setA = ['a','b']</code> y <code>setB = ['a','b','c','d']</code> , entonces el subconjunto de setA y setB es: <code>setA.subset(setB)</code> debe ser <code>true</code> .
|
||||
<section id='description'>
|
||||
En este ejercicio vamos a realizar una prueba de subconjunto en 2 conjuntos de datos. Crearemos un método en nuestra estructura de datos <code>Set</code> llamada <code>subset</code> . Esto comparará el primer conjunto, contra el segundo y si el primer conjunto está completamente contenido dentro del Segundo, devolverá verdadero.
|
||||
Por ejemplo, si <code>setA = ['a','b']</code> y <code>setB = ['a','b','c','d']</code> , entonces el subconjunto de setA y setB es: <code>setA.subset(setB)</code> debe ser <code>true</code> .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -25,13 +25,13 @@ tests:
|
||||
testString: 'assert(function(){var test = new Set(); return (typeof test.subset === "function")}, "Your <code>Set</code> class should have a <code>union</code> method.");'
|
||||
- text: El primer Set () estaba contenido en el segundo Set
|
||||
testString: 'assert(function(){var setA = new Set(); var setB = new Set(); setA.add("a"); setB.add("b"); setB.add("c"); setB.add("a"); setB.add("d"); var subsetSetAB = setA.subset(setB);return (subsetSetAB === true)}, "The first Set() was contained in the second Set");'
|
||||
- text: ' <code>["a", "b"].subset(["a", "b", "c", "d"])</code> debe devolver <code>true</code> ")'
|
||||
- text: ' <code>["a", "b"].subset(["a", "b", "c", "d"])</code> debe devolver <code>true</code> ")'
|
||||
testString: 'assert(function(){var setA = new Set(); var setB = new Set(); setA.add("a"); setA.add("b"); setB.add("a"); setB.add("b"); setB.add("c"); setB.add("d"); var subsetSetAB = setA.subset(setB); return (subsetSetAB === true)}, "<code>["a", "b"].subset(["a", "b", "c", "d"])</code> should return <code>true</code>");'
|
||||
- text: ' <code>["a", "b", "c"].subset(["a", "b"])</code> debe devolver <code>false</code> ")'
|
||||
- text: ' <code>["a", "b", "c"].subset(["a", "b"])</code> debe devolver <code>false</code> ")'
|
||||
testString: 'assert(function(){var setA = new Set(); var setB = new Set(); setA.add("a"); setA.add("b"); setA.add("c"); setB.add("a"); setB.add("b"); var subsetSetAB = setA.subset(setB); return (subsetSetAB === false)}, "<code>["a", "b", "c"].subset(["a", "b"])</code> should return <code>false</code>");'
|
||||
- text: ' <code>[].subset([])</code> debe devolver <code>true</code> '
|
||||
- text: ' <code>[].subset([])</code> debe devolver <code>true</code> '
|
||||
testString: 'assert(function(){var setA = new Set(); var setB = new Set(); var subsetSetAB = setA.subset(setB); return (subsetSetAB === true)}, "<code>[].subset([])</code> should return <code>true</code>");'
|
||||
- text: ' <code>["a", "b"].subset(["c", "d"])</code> debe devolver <code>false</code> ")'
|
||||
- text: ' <code>["a", "b"].subset(["c", "d"])</code> debe devolver <code>false</code> ")'
|
||||
testString: 'assert(function(){var setA = new Set(); var setB = new Set(); setA.add("a"); setA.add("b"); setB.add("c"); setB.add("d"); var subsetSetAB = setA.subset(setB); return (subsetSetAB === false)}, "<code>["a", "b"].subset(["c", "d"])</code> should return <code>false</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,19 +6,19 @@ challengeType: 1
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Veamos los métodos .has y .size disponibles en el objeto ES6 Set.
|
||||
Primero, cree un conjunto ES6
|
||||
<code>var set = new Set([1,2,3]);</code>
|
||||
El método .has comprobará si el valor está contenido dentro del conjunto.
|
||||
<code>var hasTwo = set.has(2);</code>
|
||||
El método .size devolverá un número entero que representa el tamaño del Set
|
||||
<code>var howBig = set.size;</code>
|
||||
<section id='description'>
|
||||
Veamos los métodos .has y .size disponibles en el objeto ES6 Set.
|
||||
Primero, cree un conjunto ES6
|
||||
<code>var set = new Set([1,2,3]);</code>
|
||||
El método .has comprobará si el valor está contenido dentro del conjunto.
|
||||
<code>var hasTwo = set.has(2);</code>
|
||||
El método .size devolverá un número entero que representa el tamaño del Set
|
||||
<code>var howBig = set.size;</code>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
En este ejercicio pasaremos una matriz y un valor a la función checkSet (). Su función debe crear un conjunto ES6 a partir del argumento de la matriz. Encuentra si el conjunto contiene el argumento de valor. Encuentra el tamaño del conjunto. Y devuelve esos dos valores en una matriz.
|
||||
<section id='instructions'>
|
||||
En este ejercicio pasaremos una matriz y un valor a la función checkSet (). Su función debe crear un conjunto ES6 a partir del argumento de la matriz. Encuentra si el conjunto contiene el argumento de valor. Encuentra el tamaño del conjunto. Y devuelve esos dos valores en una matriz.
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@@ -26,7 +26,7 @@ En este ejercicio pasaremos una matriz y un valor a la función checkSet (). Su
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>checkSet([4, 5, 6], 3)</code> debe devolver [false, 3]'
|
||||
- text: ' <code>checkSet([4, 5, 6], 3)</code> debe devolver [false, 3]'
|
||||
testString: 'assert(function(){var test = checkSet([4,5,6], 3); test === [ false, 3 ]}, "<code>checkSet([4, 5, 6], 3)</code> should return [ false, 3 ]");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,21 +6,21 @@ title: 'Problem 175: Fractions involving the number of different ways a number c
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Defina f (0) = 1 y f (n) como el número de formas de escribir n como una suma de potencias de 2 donde no se produce potencia más de dos veces.
|
||||
<section id='description'>
|
||||
Defina f (0) = 1 y f (n) como el número de formas de escribir n como una suma de potencias de 2 donde no se produce potencia más de dos veces.
|
||||
|
||||
Por ejemplo, f (10) = 5 ya que hay cinco formas diferentes de expresar 10:10 = 8 + 2 = 8 + 1 + 1 = 4 + 4 + 2 = 4 + 2 + 2 + 1 + 1 = 4 + 4 + 1 + 1
|
||||
Por ejemplo, f (10) = 5 ya que hay cinco formas diferentes de expresar 10:10 = 8 + 2 = 8 + 1 + 1 = 4 + 4 + 2 = 4 + 2 + 2 + 1 + 1 = 4 + 4 + 1 + 1
|
||||
|
||||
Se puede mostrar que para cada fracción p / q (p> 0, q> 0) existe al menos un entero n tal que f (n) / f (n-1) = p / q.
|
||||
Por ejemplo, la n más pequeña para la cual f (n) / f (n-1) = 13/17 es 241.
|
||||
La expansión binaria de 241 es 11110001.
|
||||
Leyendo este número binario del bit más significativo al menos significativo Bit hay 4 de uno, 3 ceros y 1 de uno. Llamaremos a la cadena 4,3,1 la Expansión Binaria Acortada de 241.
|
||||
Halla la Expansión Binaria Acortada de la n más pequeña para la cual f (n) / f (n-1) = 123456789/987654321.
|
||||
Da tu respuesta como enteros separados por comas, sin espacios en blanco.
|
||||
Se puede mostrar que para cada fracción p / q (p> 0, q> 0) existe al menos un entero n tal que f (n) / f (n-1) = p / q.
|
||||
Por ejemplo, la n más pequeña para la cual f (n) / f (n-1) = 13/17 es 241.
|
||||
La expansión binaria de 241 es 11110001.
|
||||
Leyendo este número binario del bit más significativo al menos significativo Bit hay 4 de uno, 3 ceros y 1 de uno. Llamaremos a la cadena 4,3,1 la Expansión Binaria Acortada de 241.
|
||||
Halla la Expansión Binaria Acortada de la n más pequeña para la cual f (n) / f (n-1) = 123456789/987654321.
|
||||
Da tu respuesta como enteros separados por comas, sin espacios en blanco.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -29,7 +29,7 @@ Da tu respuesta como enteros separados por comas, sin espacios en blanco.
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>euler175()</code> debe devolver 1, 13717420, 8.'
|
||||
- text: ' <code>euler175()</code> debe devolver 1, 13717420, 8.'
|
||||
testString: 'assert.strictEqual(euler175(), 1, 13717420, 8, "<code>euler175()</code> should return 1, 13717420, 8.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,14 +6,14 @@ title: 'Problem 19: Counting Sundays'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Se le proporciona la siguiente información, pero es posible que prefiera hacer una investigación por sí mismo.
|
||||
<ul><li> El 1 de enero de 1900 fue un lunes. </li><li> Treinta días tiene septiembre, <br> Abril, junio y noviembre. <br> Todos los demás tienen treinta y uno, <br> Salvando febrero solo, <br> Que tiene veintiocho, llueva o truene. <br> Y en años bisiestos, veintinueve. </li><li> Un año bisiesto ocurre en cualquier año divisible por 4, pero no en un siglo a menos que sea divisible por 400. </li>
|
||||
¿Cuántos domingos cayeron el primer día del mes durante el siglo veinte (1 de enero de 1901 a 31 de diciembre de 2000)?
|
||||
<section id='description'>
|
||||
Se le proporciona la siguiente información, pero es posible que prefiera hacer una investigación por sí mismo.
|
||||
<ul><li> El 1 de enero de 1900 fue un lunes. </li><li> Treinta días tiene septiembre, <br> Abril, junio y noviembre. <br> Todos los demás tienen treinta y uno, <br> Salvando febrero solo, <br> Que tiene veintiocho, llueva o truene. <br> Y en años bisiestos, veintinueve. </li><li> Un año bisiesto ocurre en cualquier año divisible por 4, pero no en un siglo a menos que sea divisible por 400. </li>
|
||||
¿Cuántos domingos cayeron el primer día del mes durante el siglo veinte (1 de enero de 1901 a 31 de diciembre de 2000)?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -22,11 +22,11 @@ Se le proporciona la siguiente información, pero es posible que prefiera hacer
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>countingSundays(1943, 1946)</code> debe devolver 6.'
|
||||
- text: ' <code>countingSundays(1943, 1946)</code> debe devolver 6.'
|
||||
testString: 'assert.strictEqual(countingSundays(1943, 1946), 6, "<code>countingSundays(1943, 1946)</code> should return 6.");'
|
||||
- text: ' <code>countingSundays(1995, 2000)</code> debe devolver 9.'
|
||||
- text: ' <code>countingSundays(1995, 2000)</code> debe devolver 9.'
|
||||
testString: 'assert.strictEqual(countingSundays(1995, 2000), 9, "<code>countingSundays(1995, 2000)</code> should return 9.");'
|
||||
- text: ' <code>countingSundays(1901, 2000)</code> debe devolver 171.'
|
||||
- text: ' <code>countingSundays(1901, 2000)</code> debe devolver 171.'
|
||||
testString: 'assert.strictEqual(countingSundays(1901, 2000), 171, "<code>countingSundays(1901, 2000)</code> should return 171.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,27 +6,27 @@ title: 'Problem 220: Heighway Dragon'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Sea D0 la cadena de dos letras "Fa". Para n≥1, derive Dn de Dn-1 mediante las reglas de reescritura de cadenas:
|
||||
<section id='description'>
|
||||
Sea D0 la cadena de dos letras "Fa". Para n≥1, derive Dn de Dn-1 mediante las reglas de reescritura de cadenas:
|
||||
|
||||
"a" → "aRbFR"
|
||||
"b" → "LFaLb"
|
||||
"a" → "aRbFR"
|
||||
"b" → "LFaLb"
|
||||
|
||||
Por lo tanto, D0 = "Fa", D1 = "FaRbFR" , D2 = "FaRbFRRLFaLbFR", y así sucesivamente.
|
||||
Por lo tanto, D0 = "Fa", D1 = "FaRbFR" , D2 = "FaRbFRRLFaLbFR", y así sucesivamente.
|
||||
|
||||
Estas cadenas pueden interpretarse como instrucciones para un programa de gráficos de computadora, con "F" que significa "dibujar una unidad", "L" que significa "girar a la izquierda 90 grados", "R" que significa "girar a la derecha 90 grados", y "a" y "b" se ignoran. La posición inicial del cursor de la computadora es (0,0), apuntando hacia arriba (0,1).
|
||||
Estas cadenas pueden interpretarse como instrucciones para un programa de gráficos de computadora, con "F" que significa "dibujar una unidad", "L" que significa "girar a la izquierda 90 grados", "R" que significa "girar a la derecha 90 grados", y "a" y "b" se ignoran. La posición inicial del cursor de la computadora es (0,0), apuntando hacia arriba (0,1).
|
||||
|
||||
Entonces Dn es un dibujo exótico conocido como el Dragón Heighway de orden n. Por ejemplo, D10 se muestra a continuación; contando cada "F" como un paso, el punto resaltado en (18,16) es la posición alcanzada después de 500 pasos.
|
||||
Entonces Dn es un dibujo exótico conocido como el Dragón Heighway de orden n. Por ejemplo, D10 se muestra a continuación; contando cada "F" como un paso, el punto resaltado en (18,16) es la posición alcanzada después de 500 pasos.
|
||||
|
||||
|
||||
|
||||
|
||||
¿Cuál es la posición del cursor después de 1012 pasos en D50?
|
||||
Da tu respuesta en la forma x, y sin espacios.
|
||||
¿Cuál es la posición del cursor después de 1012 pasos en D50?
|
||||
Da tu respuesta en la forma x, y sin espacios.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -35,7 +35,7 @@ Da tu respuesta en la forma x, y sin espacios.
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>euler220()</code> debe devolver 139776, 963904.'
|
||||
- text: ' <code>euler220()</code> debe devolver 139776, 963904.'
|
||||
testString: 'assert.strictEqual(euler220(), 139776, 963904, "<code>euler220()</code> should return 139776, 963904.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,14 +6,14 @@ title: 'Problem 34: Digit factorials'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
145 es un número curioso, como 1! + 4! + 5! = 1 + 24 + 120 = 145.
|
||||
Encuentra los números y la suma de los números que son iguales a la suma del factorial de sus dígitos.
|
||||
Nota: como 1! = 1 y 2! = 2 no son sumas que no están incluidas.
|
||||
<section id='description'>
|
||||
145 es un número curioso, como 1! + 4! + 5! = 1 + 24 + 120 = 145.
|
||||
Encuentra los números y la suma de los números que son iguales a la suma del factorial de sus dígitos.
|
||||
Nota: como 1! = 1 y 2! = 2 no son sumas que no están incluidas.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -22,7 +22,7 @@ Nota: como 1! = 1 y 2! = 2 no son sumas que no están incluidas.
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>digitFactorial()</code> debe devolver {suma: 40730, números: [145, 40585]}.'
|
||||
- text: ' <code>digitFactorial()</code> debe devolver {suma: 40730, números: [145, 40585]}.'
|
||||
testString: 'assert.deepEqual(digitFactorial(), { sum: 40730, numbers: [145, 40585] }, "<code>digitFactorial()</code> should return { sum: 40730, numbers: [145, 40585] }.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,33 +6,33 @@ title: 'Problem 399: Squarefree Fibonacci Numbers'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Los primeros 15 números de fibonacci son:
|
||||
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610.
|
||||
Se puede ver que 8 y 144 no son cuadrados libres: 8 es divisible por 4 y 144 es divisible por 4 y por 9.
|
||||
Así que los primeros 13 números de fibonacci cuadrados libres son:
|
||||
1,1,2,3,5,13 , 21,34,55,89,233,377 y 610.
|
||||
<section id='description'>
|
||||
Los primeros 15 números de fibonacci son:
|
||||
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610.
|
||||
Se puede ver que 8 y 144 no son cuadrados libres: 8 es divisible por 4 y 144 es divisible por 4 y por 9.
|
||||
Así que los primeros 13 números de fibonacci cuadrados libres son:
|
||||
1,1,2,3,5,13 , 21,34,55,89,233,377 y 610.
|
||||
|
||||
|
||||
El número de fibonacci número 200 número cuadrado es:
|
||||
971183874599339129547649988289594072811608739584170445.
|
||||
Los últimos dieciséis dígitos de este número son: 1608739584170445 y en Scientific Number este número puede ser comprado.
|
||||
El número de fibonacci número 200 número cuadrado es:
|
||||
971183874599339129547649988289594072811608739584170445.
|
||||
Los últimos dieciséis dígitos de este número son: 1608739584170445 y en Scientific Number este número puede ser comprado.
|
||||
|
||||
|
||||
Encuentre el número de 000 000 000 de fibonacci sin cuadrados.
|
||||
Indique en su respuesta los últimos dieciséis dígitos seguidos de una coma seguida del número en notación científica (redondeado a un dígito después del punto decimal).
|
||||
Para el número 200 de squarefree, la respuesta habría sido: 1608739584170445,9.7e53
|
||||
Encuentre el número de 000 000 000 de fibonacci sin cuadrados.
|
||||
Indique en su respuesta los últimos dieciséis dígitos seguidos de una coma seguida del número en notación científica (redondeado a un dígito después del punto decimal).
|
||||
Para el número 200 de squarefree, la respuesta habría sido: 1608739584170445,9.7e53
|
||||
|
||||
|
||||
|
||||
Nota:
|
||||
Para este problema, suponga que para cada primo p, el primer número de fibonacci divisible por p no es divisible por p2 (esto es parte de la conjetura de Wall). Esto se ha verificado para números primos ≤ 3 · 1015, pero no se ha probado en general.
|
||||
Nota:
|
||||
Para este problema, suponga que para cada primo p, el primer número de fibonacci divisible por p no es divisible por p2 (esto es parte de la conjetura de Wall). Esto se ha verificado para números primos ≤ 3 · 1015, pero no se ha probado en general.
|
||||
|
||||
Si sucede que la conjetura es falsa, no se garantiza que la respuesta aceptada a este problema sea el número de 100 000 000 de fibonacci sin cuadrar cuadrado, sino que representa solo un límite inferior para ese número.
|
||||
Si sucede que la conjetura es falsa, no se garantiza que la respuesta aceptada a este problema sea el número de 100 000 000 de fibonacci sin cuadrar cuadrado, sino que representa solo un límite inferior para ese número.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -41,7 +41,7 @@ Si sucede que la conjetura es falsa, no se garantiza que la respuesta aceptada a
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>euler399()</code> debe devolver 1508395636674243, 6.5e27330467.'
|
||||
- text: ' <code>euler399()</code> debe devolver 1508395636674243, 6.5e27330467.'
|
||||
testString: 'assert.strictEqual(euler399(), 1508395636674243, 6.5e27330467, "<code>euler399()</code> should return 1508395636674243, 6.5e27330467.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,29 +6,29 @@ title: 'Problem 419: Look and say sequence'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La secuencia de buscar y decir va 1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, ...
|
||||
La secuencia comienza con 1 y todos los demás miembros se obtienen describiendo el miembro anterior en términos de dígitos consecutivos.
|
||||
Ayuda hacer esto en voz alta:
|
||||
1 es 'uno uno' → 11
|
||||
11 es 'dos unos' → 21
|
||||
21 es 'uno dos y uno uno' → 1211
|
||||
1211 es 'uno uno, uno dos y dos ones '→ 111221
|
||||
111221 es' tres one, two twos and one '→ 312211
|
||||
...
|
||||
<section id='description'>
|
||||
La secuencia de buscar y decir va 1, 11, 21, 1211, 111221, 312211, 13112221, 1113213211, ...
|
||||
La secuencia comienza con 1 y todos los demás miembros se obtienen describiendo el miembro anterior en términos de dígitos consecutivos.
|
||||
Ayuda hacer esto en voz alta:
|
||||
1 es 'uno uno' → 11
|
||||
11 es 'dos unos' → 21
|
||||
21 es 'uno dos y uno uno' → 1211
|
||||
1211 es 'uno uno, uno dos y dos ones '→ 111221
|
||||
111221 es' tres one, two twos and one '→ 312211
|
||||
...
|
||||
|
||||
|
||||
Defina A (n), B (n) y C (n) como el número de unidades, twos y threes en el elemento n 'n de la secuencia respectivamente.
|
||||
Se puede verificar que A (40) = 31254, B (40) = 20259 y C (40) = 11625.
|
||||
Defina A (n), B (n) y C (n) como el número de unidades, twos y threes en el elemento n 'n de la secuencia respectivamente.
|
||||
Se puede verificar que A (40) = 31254, B (40) = 20259 y C (40) = 11625.
|
||||
|
||||
|
||||
Encuentre A (n), B (n) y C (n) para n = 1012.
|
||||
Da tu respuesta módulo 230 y separa tus valores para A, B y C con una coma.
|
||||
Ej. Para n = 40 la respuesta sería 31254,20259,11625
|
||||
Encuentre A (n), B (n) y C (n) para n = 1012.
|
||||
Da tu respuesta módulo 230 y separa tus valores para A, B y C con una coma.
|
||||
Ej. Para n = 40 la respuesta sería 31254,20259,11625
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -37,7 +37,7 @@ Ej. Para n = 40 la respuesta sería 31254,20259,11625
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>euler419()</code> debe devolver 998567458, 1046245404, 43363922.'
|
||||
- text: ' <code>euler419()</code> debe devolver 998567458, 1046245404, 43363922.'
|
||||
testString: 'assert.strictEqual(euler419(), 998567458, 1046245404, 43363922, "<code>euler419()</code> should return 998567458, 1046245404, 43363922.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,21 +6,21 @@ title: 'Problem 43: Sub-string divisibility'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El número, 1406357289, es un número pandigital de 0 a 9 porque está formado por cada uno de los dígitos 0 a 9 en algún orden, pero también tiene una propiedad de divisibilidad de sub-cadena bastante interesante.
|
||||
Sea d1 el primer dígito, d2 el segundo dígito, etc. De esta manera, notamos lo siguiente:
|
||||
d2d3d4 = 406 es divisible por 2
|
||||
d3d4d5 = 063 es divisible por 3
|
||||
d4d5d6 = 635 es divisible por 5
|
||||
d5d6d7 = 357 es divisible por 7
|
||||
d6d7d8 = 572 es divisible por 11
|
||||
d7d8d9 = 728 es divisible por 13
|
||||
d8d9d10 = 289 es divisible por 17
|
||||
Encuentra los números de todos los 0 a 9 números pandigitales con esta propiedad.
|
||||
<section id='description'>
|
||||
El número, 1406357289, es un número pandigital de 0 a 9 porque está formado por cada uno de los dígitos 0 a 9 en algún orden, pero también tiene una propiedad de divisibilidad de sub-cadena bastante interesante.
|
||||
Sea d1 el primer dígito, d2 el segundo dígito, etc. De esta manera, notamos lo siguiente:
|
||||
d2d3d4 = 406 es divisible por 2
|
||||
d3d4d5 = 063 es divisible por 3
|
||||
d4d5d6 = 635 es divisible por 5
|
||||
d5d6d7 = 357 es divisible por 7
|
||||
d6d7d8 = 572 es divisible por 11
|
||||
d7d8d9 = 728 es divisible por 13
|
||||
d8d9d10 = 289 es divisible por 17
|
||||
Encuentra los números de todos los 0 a 9 números pandigitales con esta propiedad.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -29,7 +29,7 @@ Encuentra los números de todos los 0 a 9 números pandigitales con esta propied
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>substringDivisibility()</code> debe devolver [1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289].'
|
||||
- text: ' <code>substringDivisibility()</code> debe devolver [1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289].'
|
||||
testString: 'assert.deepEqual(substringDivisibility(), [ 1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289 ], "<code>substringDivisibility()</code> should return [ 1430952867, 1460357289, 1406357289, 4130952867, 4160357289, 4106357289 ].");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,19 +6,19 @@ title: 'Problem 47: Distinct primes factors'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Los dos primeros números consecutivos que tienen dos factores primos distintos son:
|
||||
<div style='padding-left: 4em;'> 14 = 2 × 7 </div>
|
||||
<div style='padding-left: 4em;'> 15 = 3 × 5 </div>
|
||||
Los primeros tres números consecutivos que tienen tres factores primos distintos son:
|
||||
<div style='padding-left: 4em;'> 644 = 2² × 7 × 23 </div>
|
||||
<div style='padding-left: 4em;'> 645 = 3 × 5 × 43 </div>
|
||||
<div style='padding-left: 4em;'> 646 = 2 × 17 × 19 </div>
|
||||
Encuentre los primeros cuatro enteros consecutivos que tengan cuatro factores primos distintos cada uno. ¿Cuál es el primero de estos números?
|
||||
<section id='description'>
|
||||
Los dos primeros números consecutivos que tienen dos factores primos distintos son:
|
||||
<div style='padding-left: 4em;'> 14 = 2 × 7 </div>
|
||||
<div style='padding-left: 4em;'> 15 = 3 × 5 </div>
|
||||
Los primeros tres números consecutivos que tienen tres factores primos distintos son:
|
||||
<div style='padding-left: 4em;'> 644 = 2² × 7 × 23 </div>
|
||||
<div style='padding-left: 4em;'> 645 = 3 × 5 × 43 </div>
|
||||
<div style='padding-left: 4em;'> 646 = 2 × 17 × 19 </div>
|
||||
Encuentre los primeros cuatro enteros consecutivos que tengan cuatro factores primos distintos cada uno. ¿Cuál es el primero de estos números?
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -27,11 +27,11 @@ Encuentre los primeros cuatro enteros consecutivos que tengan cuatro factores pr
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>distinctPrimeFactors(2, 2)</code> debe devolver 14.'
|
||||
- text: ' <code>distinctPrimeFactors(2, 2)</code> debe devolver 14.'
|
||||
testString: 'assert.strictEqual(distinctPrimeFactors(2, 2), 14, "<code>distinctPrimeFactors(2, 2)</code> should return 14.");'
|
||||
- text: ' <code>distinctPrimeFactors(3, 3)</code> debe devolver 644.'
|
||||
- text: ' <code>distinctPrimeFactors(3, 3)</code> debe devolver 644.'
|
||||
testString: 'assert.strictEqual(distinctPrimeFactors(3, 3), 644, "<code>distinctPrimeFactors(3, 3)</code> should return 644.");'
|
||||
- text: ' <code>distinctPrimeFactors(4, 4)</code> debe devolver 134043.'
|
||||
- text: ' <code>distinctPrimeFactors(4, 4)</code> debe devolver 134043.'
|
||||
testString: 'assert.strictEqual(distinctPrimeFactors(4, 4), 134043, "<code>distinctPrimeFactors(4, 4)</code> should return 134043.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,13 +6,13 @@ title: 'Problem 48: Self powers'
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La serie, 1 <sup>1</sup> + 2 <sup>2</sup> + 3 <sup>3</sup> + ... + 10 <sup>10</sup> = 10405071317.
|
||||
Encuentre los últimos diez dígitos de la serie, 1 <sup>1</sup> + 2 <sup>2</sup> + 3 <sup>3</sup> + ... + 1000 <sup>1000</sup> .
|
||||
<section id='description'>
|
||||
La serie, 1 <sup>1</sup> + 2 <sup>2</sup> + 3 <sup>3</sup> + ... + 10 <sup>10</sup> = 10405071317.
|
||||
Encuentre los últimos diez dígitos de la serie, 1 <sup>1</sup> + 2 <sup>2</sup> + 3 <sup>3</sup> + ... + 1000 <sup>1000</sup> .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -21,13 +21,13 @@ Encuentre los últimos diez dígitos de la serie, 1 <sup>1</sup> + 2 <sup>2</sup
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: ' <code>selfPowers(10, 3)</code> debe devolver 317.'
|
||||
- text: ' <code>selfPowers(10, 3)</code> debe devolver 317.'
|
||||
testString: 'assert.strictEqual(selfPowers(10, 3), 317, "<code>selfPowers(10, 3)</code> should return 317.");'
|
||||
- text: ' <code>selfPowers(150, 6)</code> debe devolver 29045.'
|
||||
- text: ' <code>selfPowers(150, 6)</code> debe devolver 29045.'
|
||||
testString: 'assert.strictEqual(selfPowers(150, 6), 29045, "<code>selfPowers(150, 6)</code> should return 29045.");'
|
||||
- text: ' <code>selfPowers(673, 7)</code> debe devolver 2473989.'
|
||||
- text: ' <code>selfPowers(673, 7)</code> debe devolver 2473989.'
|
||||
testString: 'assert.strictEqual(selfPowers(673, 7), 2473989, "<code>selfPowers(673, 7)</code> should return 2473989.");'
|
||||
- text: ' <code>selfPowers(1000, 10)</code> debe devolver 9110846700.'
|
||||
- text: ' <code>selfPowers(1000, 10)</code> debe devolver 9110846700.'
|
||||
testString: 'assert.strictEqual(selfPowers(1000, 10), 9110846700, "<code>selfPowers(1000, 10)</code> should return 9110846700.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,20 +6,20 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Estos definen tres clasificaciones de enteros positivos basados en sus <a href="http://rosettacode.org/wiki/Proper divisors" title="Divisores adecuados">divisores apropiados</a> . </p>
|
||||
<p> Sea $ P (n) $ la suma de los divisores apropiados de n, donde los divisores apropiados son todos enteros positivos n distintos de n en sí. </p>
|
||||
<p> Si <code>P(n) < n</code> entonces n se clasifica como "deficiente" </p>
|
||||
<p> Si <code>P(n) === n</code> , n se clasifica como "perfecto" </p>
|
||||
<p> Si <code>P(n) > n</code> entonces n se clasifica como "abundante" </p>
|
||||
<p> Ejemplo: </p>
|
||||
<p> 6 tiene divisores propios de 1, 2 y 3. </p>
|
||||
<p> 1 + 2 + 3 = 6, entonces 6 se clasifica como un número perfecto. </p>
|
||||
<p> Implemente una función que calcula cuántos de los enteros de 1 a 20,000 (inclusive) están en cada una de las tres clases. Muestra el resultado como una matriz en el siguiente formato <code>[deficient, perfect, abundant]</code> . </p>
|
||||
<section id='description'>
|
||||
<p> Estos definen tres clasificaciones de enteros positivos basados en sus <a href="http://rosettacode.org/wiki/Proper divisors" title="Divisores adecuados">divisores apropiados</a> . </p>
|
||||
<p> Sea $ P (n) $ la suma de los divisores apropiados de n, donde los divisores apropiados son todos enteros positivos n distintos de n en sí. </p>
|
||||
<p> Si <code>P(n) < n</code> entonces n se clasifica como "deficiente" </p>
|
||||
<p> Si <code>P(n) === n</code> , n se clasifica como "perfecto" </p>
|
||||
<p> Si <code>P(n) > n</code> entonces n se clasifica como "abundante" </p>
|
||||
<p> Ejemplo: </p>
|
||||
<p> 6 tiene divisores propios de 1, 2 y 3. </p>
|
||||
<p> 1 + 2 + 3 = 6, entonces 6 se clasifica como un número perfecto. </p>
|
||||
<p> Implemente una función que calcula cuántos de los enteros de 1 a 20,000 (inclusive) están en cada una de las tres clases. Muestra el resultado como una matriz en el siguiente formato <code>[deficient, perfect, abundant]</code> . </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -34,7 +34,7 @@ tests:
|
||||
testString: 'assert(Array.isArray(getDPA(100)), "<code>getDPA</code> should return an array.");'
|
||||
- text: <code>getDPA</code> valor de retorno de <code>getDPA</code> debe tener una longitud de 3.
|
||||
testString: 'assert(getDPA(100).length === 3, "<code>getDPA</code> return value should have a length of 3.");'
|
||||
- text: ' <code>getDPA(20000)</code> debe ser igual a [15043, 4, 4953]'
|
||||
- text: ' <code>getDPA(20000)</code> debe ser igual a [15043, 4, 4953]'
|
||||
testString: 'assert.deepEqual(getDPA(20000), solution, "<code>getDPA(20000)</code> should equal [15043, 4, 4953]");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,16 +6,16 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Cree una función que tome un solo argumento (numérico) y devuelva otra función que sea un acumulador. La función del acumulador devuelto a su vez también toma un solo argumento numérico y devuelve la suma de todos los valores numéricos pasados hasta ese acumulador (incluido el valor inicial pasado cuando se creó el acumulador). </p>
|
||||
<p> Reglas: </p>
|
||||
<p> No utilice variables globales. </p>
|
||||
<p> Insinuación: </p>
|
||||
<p> Los cierres salvan el estado exterior. </p>
|
||||
<section id='description'>
|
||||
<p> Cree una función que tome un solo argumento (numérico) y devuelva otra función que sea un acumulador. La función del acumulador devuelto a su vez también toma un solo argumento numérico y devuelve la suma de todos los valores numéricos pasados hasta ese acumulador (incluido el valor inicial pasado cuando se creó el acumulador). </p>
|
||||
<p> Reglas: </p>
|
||||
<p> No utilice variables globales. </p>
|
||||
<p> Insinuación: </p>
|
||||
<p> Los cierres salvan el estado exterior. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -30,7 +30,7 @@ tests:
|
||||
testString: 'assert(typeof accumulator(0) === "function", "<code>accumulator(0)</code> should return a function.");'
|
||||
- text: <code>accumulator(0)(2)</code> debe devolver un número.
|
||||
testString: 'assert(typeof accumulator(0)(2) === "number", "<code>accumulator(0)(2)</code> should return a number.");'
|
||||
- text: 'Pasar los valores 3, -4, 1.5 y 5 debería devolver 5.5.'
|
||||
- text: 'Pasar los valores 3, -4, 1.5 y 5 debería devolver 5.5.'
|
||||
testString: 'assert(testFn(5) === 5.5, "Passing in the values 3, -4, 1.5, and 5 should return 5.5.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,20 +6,20 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> La función de Ackermann es un ejemplo clásico de una función recursiva, especialmente porque no es una función recursiva primitiva. Crece muy rápidamente en valor, al igual que el tamaño de su árbol de llamadas. </p>
|
||||
<p> La función de Ackermann se define generalmente de la siguiente manera: </p>
|
||||
$ A (m, n) =
|
||||
\ begin {cases}
|
||||
n + 1 & \ mbox {if} m = 0 \\
|
||||
A (m-1, 1) & \ mbox {if} m> 0 \ mbox {y} n = 0 \\
|
||||
A (m-1, A (m, n-1)) & \ mbox {if} m> 0 \ mbox {y} n> 0.
|
||||
\ end {cases} $ $
|
||||
<p> Sus argumentos nunca son negativos y siempre termina. Escriba una función que devuelva el valor de $ A (m, n) $. Se prefiere la precisión arbitraria (ya que la función crece tan rápidamente), pero no es obligatoria. </p>
|
||||
<section id='description'>
|
||||
<p> La función de Ackermann es un ejemplo clásico de una función recursiva, especialmente porque no es una función recursiva primitiva. Crece muy rápidamente en valor, al igual que el tamaño de su árbol de llamadas. </p>
|
||||
<p> La función de Ackermann se define generalmente de la siguiente manera: </p>
|
||||
$ A (m, n) =
|
||||
\ begin {cases}
|
||||
n + 1 & \ mbox {if} m = 0 \\
|
||||
A (m-1, 1) & \ mbox {if} m> 0 \ mbox {y} n = 0 \\
|
||||
A (m-1, A (m, n-1)) & \ mbox {if} m> 0 \ mbox {y} n> 0.
|
||||
\ end {cases} $ $
|
||||
<p> Sus argumentos nunca son negativos y siempre termina. Escriba una función que devuelva el valor de $ A (m, n) $. Se prefiere la precisión arbitraria (ya que la función crece tan rápidamente), pero no es obligatoria. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -30,13 +30,13 @@ A (m-1, A (m, n-1)) & \ mbox {if} m> 0 \ mbox {y} n> 0.
|
||||
tests:
|
||||
- text: <code>ack</code> es una función.
|
||||
testString: 'assert(typeof ack === "function", "<code>ack</code> is a function.");'
|
||||
- text: ' <code>ack(0, 0)</code> debe devolver 1.'
|
||||
- text: ' <code>ack(0, 0)</code> debe devolver 1.'
|
||||
testString: 'assert(ack(0, 0) === 1, "<code>ack(0, 0)</code> should return 1.");'
|
||||
- text: ' <code>ack(1, 1)</code> debe devolver 3.'
|
||||
- text: ' <code>ack(1, 1)</code> debe devolver 3.'
|
||||
testString: 'assert(ack(1, 1) === 3, "<code>ack(1, 1)</code> should return 3.");'
|
||||
- text: ' <code>ack(2, 5)</code> debe devolver 13.'
|
||||
- text: ' <code>ack(2, 5)</code> debe devolver 13.'
|
||||
testString: 'assert(ack(2, 5) === 13, "<code>ack(2, 5)</code> should return 13.");'
|
||||
- text: ' <code>ack(3, 3)</code> debe devolver 61.'
|
||||
- text: ' <code>ack(3, 3)</code> debe devolver 61.'
|
||||
testString: 'assert(ack(3, 3) === 61, "<code>ack(3, 3)</code> should return 61.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,32 +6,32 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Dado un archivo de texto de muchas líneas, donde los campos dentro de una línea están delineados por un solo carácter de <code>$</code> , escriba un programa que alinee cada columna de campos asegurándose de que las palabras en cada columna estén separadas por al menos un espacio. Además, permita que cada palabra en una columna se justifique a la izquierda, a la derecha o al centro dentro de su columna. </p>
|
||||
<p> Usa el siguiente texto para probar tus programas: </p>
|
||||
<pre>
|
||||
Dado $ a $ texto $ archivo $ de $ muchas $ líneas
|
||||
donde $ campos $ dentro de $ a $ línea $
|
||||
son $ delineados $ por $ a $ simple $ 'dólar' $ carácter
|
||||
escribe $ a $ programa
|
||||
ese $ alinea $ cada $ columna $ de $ campos
|
||||
por $ asegurando $ que $ palabras $ en $ cada $
|
||||
columna $ están $ separados $ por $ en $ al menos $ un $ espacio.
|
||||
Además, $ permita $ por $ cada $ palabra $ en $ a $ columna $ a $ sea $ o bien $ dejó $
|
||||
justificado, $ derecho $ justificó
|
||||
o $ centro $ justificado dentro de $ su $ columna.
|
||||
</pre>
|
||||
<p> Tenga en cuenta que: </p>
|
||||
Las líneas de texto de entrada de ejemplo pueden, o no, tener caracteres de dólar al final.
|
||||
Todas las columnas deben compartir la misma alineación.
|
||||
Los caracteres de espacio consecutivo producidos adyacentes al final de las líneas son insignificantes para los propósitos de la tarea.
|
||||
El texto de salida se verá en una fuente mono-espaciada en un editor de texto plano o terminal básico.
|
||||
El espacio mínimo entre columnas debe calcularse a partir del texto y no estar codificado.
|
||||
No es un requisito agregar caracteres de separación entre o alrededor de las columnas.
|
||||
<section id='description'>
|
||||
<p> Dado un archivo de texto de muchas líneas, donde los campos dentro de una línea están delineados por un solo carácter de <code>$</code> , escriba un programa que alinee cada columna de campos asegurándose de que las palabras en cada columna estén separadas por al menos un espacio. Además, permita que cada palabra en una columna se justifique a la izquierda, a la derecha o al centro dentro de su columna. </p>
|
||||
<p> Usa el siguiente texto para probar tus programas: </p>
|
||||
<pre>
|
||||
Dado $ a $ texto $ archivo $ de $ muchas $ líneas
|
||||
donde $ campos $ dentro de $ a $ línea $
|
||||
son $ delineados $ por $ a $ simple $ 'dólar' $ carácter
|
||||
escribe $ a $ programa
|
||||
ese $ alinea $ cada $ columna $ de $ campos
|
||||
por $ asegurando $ que $ palabras $ en $ cada $
|
||||
columna $ están $ separados $ por $ en $ al menos $ un $ espacio.
|
||||
Además, $ permita $ por $ cada $ palabra $ en $ a $ columna $ a $ sea $ o bien $ dejó $
|
||||
justificado, $ derecho $ justificó
|
||||
o $ centro $ justificado dentro de $ su $ columna.
|
||||
</pre>
|
||||
<p> Tenga en cuenta que: </p>
|
||||
Las líneas de texto de entrada de ejemplo pueden, o no, tener caracteres de dólar al final.
|
||||
Todas las columnas deben compartir la misma alineación.
|
||||
Los caracteres de espacio consecutivo producidos adyacentes al final de las líneas son insignificantes para los propósitos de la tarea.
|
||||
El texto de salida se verá en una fuente mono-espaciada en un editor de texto plano o terminal básico.
|
||||
El espacio mínimo entre columnas debe calcularse a partir del texto y no estar codificado.
|
||||
No es un requisito agregar caracteres de separación entre o alrededor de las columnas.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -42,11 +42,11 @@ No es un requisito agregar caracteres de separación entre o alrededor de las co
|
||||
tests:
|
||||
- text: <code>formatText</code> es una función.
|
||||
testString: 'assert(typeof formatText === "function", "<code>formatText</code> is a function.");'
|
||||
- text: ' <code>formatText</code> con la entrada anterior y la justificación "correcta" debe producir lo siguiente:'
|
||||
- text: ' <code>formatText</code> con la entrada anterior y la justificación "correcta" debe producir lo siguiente:'
|
||||
testString: 'assert.strictEqual(formatText(testInput, "right"), rightAligned, "<code>formatText</code> with the above input and "right" justification should produce the following: ");'
|
||||
- text: ' <code>formatText</code> con la entrada anterior y la justificación "izquierda" debe producir lo siguiente:'
|
||||
- text: ' <code>formatText</code> con la entrada anterior y la justificación "izquierda" debe producir lo siguiente:'
|
||||
testString: 'assert.strictEqual(formatText(testInput, "left"), leftAligned, "<code>formatText</code> with the above input and "left" justification should produce the following: ");'
|
||||
- text: ' <code>formatText</code> con la entrada anterior y la justificación "central" debe producir lo siguiente:'
|
||||
- text: ' <code>formatText</code> con la entrada anterior y la justificación "central" debe producir lo siguiente:'
|
||||
testString: 'assert.strictEqual(formatText(testInput, "center"), centerAligned, "<code>formatText</code> with the above input and "center" justification should produce the following: ");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,22 +6,22 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Se dice que dos enteros $ N $ y $ M $ son <a href="https://en.wikipedia.org/wiki/Amicable numbers" title="wp: números amistosos">pares amigables</a> si $ N \ neq M $ y la suma de los <a href="http://rosettacode.org/wiki/Proper divisors" title="Divisores adecuados">divisores apropiados</a> de $ N $ ($ \ mathrm {suma} (\ mathrm {propDivs} (N) ) $) $ = M $ así como $ \ mathrm {suma} (\ mathrm {propDivs} (M)) = N $.
|
||||
Ejemplo:
|
||||
1184 y 1210 son un par amigable, con divisores apropiados:
|
||||
1, 2, 4, 8, 16, 32, 37, 74, 148, 296, 592 y
|
||||
1, 2, 5, 10, 11, 22, 55, 110, 121, 242, 605 respectivamente.
|
||||
Tarea:
|
||||
Calcula y muestra aquí los pares de amigos por debajo de 20,000 (hay ocho).
|
||||
Tareas relacionadas
|
||||
<a href="http://rosettacode.org/wiki/Proper divisors" title="Divisores adecuados">Divisores apropiados</a>
|
||||
<a href="http://rosettacode.org/wiki/Abundant, deficient and perfect number classifications" title="Numerosas, deficientes y perfectas clasificaciones numéricas.">Clasificaciones numéricas abundantes, deficientes y perfectas</a>
|
||||
<a href="http://rosettacode.org/wiki/Aliquot sequence classifications" title="Clasificaciones de secuencias alícuotas">Clasificaciones de secuencias de alícuotas</a> y su clasificación amistosa.
|
||||
<section id='description'>
|
||||
Se dice que dos enteros $ N $ y $ M $ son <a href="https://en.wikipedia.org/wiki/Amicable numbers" title="wp: números amistosos">pares amigables</a> si $ N \ neq M $ y la suma de los <a href="http://rosettacode.org/wiki/Proper divisors" title="Divisores adecuados">divisores apropiados</a> de $ N $ ($ \ mathrm {suma} (\ mathrm {propDivs} (N) ) $) $ = M $ así como $ \ mathrm {suma} (\ mathrm {propDivs} (M)) = N $.
|
||||
Ejemplo:
|
||||
1184 y 1210 son un par amigable, con divisores apropiados:
|
||||
1, 2, 4, 8, 16, 32, 37, 74, 148, 296, 592 y
|
||||
1, 2, 5, 10, 11, 22, 55, 110, 121, 242, 605 respectivamente.
|
||||
Tarea:
|
||||
Calcula y muestra aquí los pares de amigos por debajo de 20,000 (hay ocho).
|
||||
Tareas relacionadas
|
||||
<a href="http://rosettacode.org/wiki/Proper divisors" title="Divisores adecuados">Divisores apropiados</a>
|
||||
<a href="http://rosettacode.org/wiki/Abundant, deficient and perfect number classifications" title="Numerosas, deficientes y perfectas clasificaciones numéricas.">Clasificaciones numéricas abundantes, deficientes y perfectas</a>
|
||||
<a href="http://rosettacode.org/wiki/Aliquot sequence classifications" title="Clasificaciones de secuencias alícuotas">Clasificaciones de secuencias de alícuotas</a> y su clasificación amistosa.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -32,11 +32,11 @@ Tareas relacionadas
|
||||
tests:
|
||||
- text: <code>amicablePairsUpTo</code> es una función.
|
||||
testString: 'assert(typeof amicablePairsUpTo === "function", "<code>amicablePairsUpTo</code> is a function.");'
|
||||
- text: ' <code>amicablePairsUpTo(300)</code> debe devolver <code>[[220,284]]</code> .'
|
||||
- text: ' <code>amicablePairsUpTo(300)</code> debe devolver <code>[[220,284]]</code> .'
|
||||
testString: 'assert.deepEqual(amicablePairsUpTo(300), answer300, "<code>amicablePairsUpTo(300)</code> should return <code>[[220,284]]</code>.");'
|
||||
- text: ' <code>amicablePairsUpTo(3000)</code> debe devolver <code>[[220,284],[1184,1210],[2620,2924]]</code> .'
|
||||
- text: ' <code>amicablePairsUpTo(3000)</code> debe devolver <code>[[220,284],[1184,1210],[2620,2924]]</code> .'
|
||||
testString: 'assert.deepEqual(amicablePairsUpTo(3000), answer3000, "<code>amicablePairsUpTo(3000)</code> should return <code>[[220,284],[1184,1210],[2620,2924]]</code>.");'
|
||||
- text: ' <code>amicablePairsUpTo(20000)</code> debe devolver <code>[[220,284],[1184,1210],[2620,2924],[5020,5564],[6232,6368],[10744,10856],[12285,14595],[17296,18416]]</code> . '
|
||||
- text: ' <code>amicablePairsUpTo(20000)</code> debe devolver <code>[[220,284],[1184,1210],[2620,2924],[5020,5564],[6232,6368],[10744,10856],[12285,14595],[17296,18416]]</code> . '
|
||||
testString: 'assert.deepEqual(amicablePairsUpTo(20000), answer20000, "<code>amicablePairsUpTo(20000)</code> should return <code>[[220,284],[1184,1210],[2620,2924],[5020,5564],[6232,6368],[10744,10856],[12285,14595],[17296,18416]]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,12 +6,12 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Escribe un programa para encontrar el valor de <a href="https://en.wikipedia.org/wiki/Mode (statistics)" title="wp: modo (estadísticas)">modo</a> de una colección. </p><p> El caso donde la colección está vacía puede ser ignorado. Se debe tener cuidado para manejar el caso donde el modo no es único. </p><p> Si no es apropiado o no es posible admitir una colección general, use un vector (matriz), si es posible. Si no es apropiado o no es posible admitir un tipo de valor no especificado, use números enteros. </p>
|
||||
<section id='description'>
|
||||
<p> Escribe un programa para encontrar el valor de <a href="https://en.wikipedia.org/wiki/Mode (statistics)" title="wp: modo (estadísticas)">modo</a> de una colección. </p><p> El caso donde la colección está vacía puede ser ignorado. Se debe tener cuidado para manejar el caso donde el modo no es único. </p><p> Si no es apropiado o no es posible admitir una colección general, use un vector (matriz), si es posible. Si no es apropiado o no es posible admitir un tipo de valor no especificado, use números enteros. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -22,9 +22,9 @@ challengeType: 5
|
||||
tests:
|
||||
- text: <code>mode</code> es una función.
|
||||
testString: 'assert(typeof mode === "function", "<code>mode</code> is a function.");'
|
||||
- text: ' <code>mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17])</code> debe ser igual a <code>[6]</code> '
|
||||
- text: ' <code>mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17])</code> debe ser igual a <code>[6]</code> '
|
||||
testString: 'assert.deepEqual(mode(arr1), [6], "<code>mode([1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17])</code> should equal <code>[6]</code>");'
|
||||
- text: 'el <code>mode([1, 2, 4, 4, 1])</code> debe ser igual a <code>[1, 4]</code> .'
|
||||
- text: 'el <code>mode([1, 2, 4, 4, 1])</code> debe ser igual a <code>[1, 4]</code> .'
|
||||
testString: 'assert.deepEqual(mode(arr2).sort(), [1, 4], "<code>mode([1, 2, 4, 4, 1])</code> should equal <code>[1, 4]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,24 +6,24 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p class='rosetta__paragraph'> Calcule los tres <a class='rosetta__link--wiki' href='https://en.wikipedia.org/wiki/Pythagorean means' title="wp: medios pitagóricos">medios pitagóricos</a> del conjunto de enteros del <big>1</big> al <big>10</big> (inclusive). </p><p class='rosetta__paragraph'> Muestre que <big>$ A (x_1, \ ldots, x_n) \ geq G (x_1, \ ldots, x_n) \ geq H (x_1, \ ldots, x_n) $</big> para este conjunto de enteros positivos. </p> El más común de los tres medios, la <a class='rosetta__link--rosetta' href='http://rosettacode.org/wiki/Averages/Arithmetic mean' title="Medias / media aritmética">media aritmética</a> , es la suma de la lista dividida por su longitud: <big>$ A (x_1, \ ldots, x_n) = \ frac {x_1 + \ cdots + x_n} {n} $</big> La <a class='rosetta__link--wiki' href='https://en.wikipedia.org/wiki/Geometric mean' title="wp: media geométrica">geometría media</a> es la raíz $ n $ th del producto de la lista: <big>$ G (x_1, \ ldots, x_n) = \ sqrt [n] {x_1 \ cdots x_n} $</big> La <a class='rosetta__link--wiki' href='https://en.wikipedia.org/wiki/Harmonic mean' title="wp: media armónica">media armónica</a> es $ n $ dividida por la suma de el recíproco de cada elemento en la lista: <big>$ H (x_1, \ ldots, x_n) = \ frac {n} {\ frac {1} {x_1} + \ cdots + \ frac {1} {x_n}} $</big>
|
||||
<p class='rosetta__paragraph'> Suponga que la entrada es una matriz ordenada de todos los números inclusivos. </p>
|
||||
<p class='rosetta__paragraph'> Para la respuesta, envíe un objeto en el siguiente formato: </p>
|
||||
<pre class='rosetta__pre'>
|
||||
{
|
||||
valores: {
|
||||
Aritmética: 5.5,
|
||||
Geométrica: 4.528728688116765,
|
||||
Armónica: 3.414171521474055
|
||||
},
|
||||
prueba: 'es A> = G> = H? si '
|
||||
}
|
||||
</pre>
|
||||
<section id='description'>
|
||||
<p class='rosetta__paragraph'> Calcule los tres <a class='rosetta__link--wiki' href='https://en.wikipedia.org/wiki/Pythagorean means' title="wp: medios pitagóricos">medios pitagóricos</a> del conjunto de enteros del <big>1</big> al <big>10</big> (inclusive). </p><p class='rosetta__paragraph'> Muestre que <big>$ A (x_1, \ ldots, x_n) \ geq G (x_1, \ ldots, x_n) \ geq H (x_1, \ ldots, x_n) $</big> para este conjunto de enteros positivos. </p> El más común de los tres medios, la <a class='rosetta__link--rosetta' href='http://rosettacode.org/wiki/Averages/Arithmetic mean' title="Medias / media aritmética">media aritmética</a> , es la suma de la lista dividida por su longitud: <big>$ A (x_1, \ ldots, x_n) = \ frac {x_1 + \ cdots + x_n} {n} $</big> La <a class='rosetta__link--wiki' href='https://en.wikipedia.org/wiki/Geometric mean' title="wp: media geométrica">geometría media</a> es la raíz $ n $ th del producto de la lista: <big>$ G (x_1, \ ldots, x_n) = \ sqrt [n] {x_1 \ cdots x_n} $</big> La <a class='rosetta__link--wiki' href='https://en.wikipedia.org/wiki/Harmonic mean' title="wp: media armónica">media armónica</a> es $ n $ dividida por la suma de el recíproco de cada elemento en la lista: <big>$ H (x_1, \ ldots, x_n) = \ frac {n} {\ frac {1} {x_1} + \ cdots + \ frac {1} {x_n}} $</big>
|
||||
<p class='rosetta__paragraph'> Suponga que la entrada es una matriz ordenada de todos los números inclusivos. </p>
|
||||
<p class='rosetta__paragraph'> Para la respuesta, envíe un objeto en el siguiente formato: </p>
|
||||
<pre class='rosetta__pre'>
|
||||
{
|
||||
valores: {
|
||||
Aritmética: 5.5,
|
||||
Geométrica: 4.528728688116765,
|
||||
Armónica: 3.414171521474055
|
||||
},
|
||||
prueba: 'es A> = G> = H? si '
|
||||
}
|
||||
</pre>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -34,7 +34,7 @@ prueba: 'es A> = G> = H? si '
|
||||
tests:
|
||||
- text: <code>pythagoreanMeans</code> es una función.
|
||||
testString: 'assert(typeof pythagoreanMeans === "function", "<code>pythagoreanMeans</code> is a function.");'
|
||||
- text: ' <code>pythagoreanMeans([1, 2, ..., 10])</code> debe ser igual a la salida anterior.'
|
||||
- text: ' <code>pythagoreanMeans([1, 2, ..., 10])</code> debe ser igual a la salida anterior.'
|
||||
testString: 'assert.deepEqual(pythagoreanMeans(range1), answer1, "<code>pythagoreanMeans([1, 2, ..., 10])</code> should equal the same output above.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Calcule el <a href="https://en.wikipedia.org/wiki/Root mean square" title="wp: cuadrado de la raíz">cuadrado</a> de la <a href="https://en.wikipedia.org/wiki/Root mean square" title="wp: cuadrado de la raíz">raíz</a> de los números del 1 al 10, ambos inclusive. </p>
|
||||
<p> La raíz cuadrada media también se conoce por sus iniciales RMS (o rms) y como la media cuadrática. </p><p> El RMS se calcula como la media de los cuadrados de los números, con raíz cuadrada: </p>
|
||||
<p> <big>$ x _ {\ mathrm {rms}} = \ sqrt {{{x_1} ^ 2 + {x_2} ^ 2 + \ cdots + {x_n} ^ 2} \ over n}. $</big> </p>
|
||||
<section id='description'>
|
||||
<p> Calcule el <a href="https://en.wikipedia.org/wiki/Root mean square" title="wp: cuadrado de la raíz">cuadrado</a> de la <a href="https://en.wikipedia.org/wiki/Root mean square" title="wp: cuadrado de la raíz">raíz</a> de los números del 1 al 10, ambos inclusive. </p>
|
||||
<p> La raíz cuadrada media también se conoce por sus iniciales RMS (o rms) y como la media cuadrática. </p><p> El RMS se calcula como la media de los cuadrados de los números, con raíz cuadrada: </p>
|
||||
<p> <big>$ x _ {\ mathrm {rms}} = \ sqrt {{{x_1} ^ 2 + {x_2} ^ 2 + \ cdots + {x_n} ^ 2} \ over n}. $</big> </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -24,7 +24,7 @@ challengeType: 5
|
||||
tests:
|
||||
- text: <code>rms</code> es una función.
|
||||
testString: 'assert(typeof rms === "function", "<code>rms</code> is a function.");'
|
||||
- text: ' <code>rms([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])</code> debe ser igual a <code>6.2048368229954285</code> .'
|
||||
- text: ' <code>rms([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])</code> debe ser igual a <code>6.2048368229954285</code> .'
|
||||
testString: 'assert.equal(rms(arr1), answer1, "<code>rms([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])</code> should equal <code>6.2048368229954285</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> <a href="https://en.wikipedia.org/wiki/Charles_Babbage" title="wp: Charles_Babbage">Charles Babbage</a> , mirando el tipo de problemas que su motor analítico podría resolver, dio este ejemplo: </p>
|
||||
<blockquote> What is the smallest positive integer whose square ends in the digits 269,696?</blockquote>
|
||||
<p> - Babbage, carta a Lord Bowden, 1837; ver Hollingdale y Tootill, <i>Electronic Computers</i> , segunda edición, 1970, pág. 125. </p>
|
||||
<p> Pensó que la respuesta podría ser 99,736, cuyo cuadrado es 9,947,269,696; pero no podía estar seguro. </p>
|
||||
<p> La tarea es averiguar si Babbage tuvo la respuesta correcta. </p>
|
||||
<p> Implemente una función para devolver el entero más bajo que satisfaga el problema de Babbage. Si Babbage tenía razón, devuelve el número de Babbage. </p>
|
||||
<section id='description'>
|
||||
<p> <a href="https://en.wikipedia.org/wiki/Charles_Babbage" title="wp: Charles_Babbage">Charles Babbage</a> , mirando el tipo de problemas que su motor analítico podría resolver, dio este ejemplo: </p>
|
||||
<blockquote> What is the smallest positive integer whose square ends in the digits 269,696?</blockquote>
|
||||
<p> - Babbage, carta a Lord Bowden, 1837; ver Hollingdale y Tootill, <i>Electronic Computers</i> , segunda edición, 1970, pág. 125. </p>
|
||||
<p> Pensó que la respuesta podría ser 99,736, cuyo cuadrado es 9,947,269,696; pero no podía estar seguro. </p>
|
||||
<p> La tarea es averiguar si Babbage tuvo la respuesta correcta. </p>
|
||||
<p> Implemente una función para devolver el entero más bajo que satisfaga el problema de Babbage. Si Babbage tenía razón, devuelve el número de Babbage. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -27,7 +27,7 @@ challengeType: 5
|
||||
tests:
|
||||
- text: <code>babbage</code> es una función.
|
||||
testString: 'assert(typeof babbage === "function", "<code>babbage</code> is a function.");'
|
||||
- text: ' <code>babbage(99736, 269696)</code> no debe devolver 99736 (hay una respuesta más pequeña).'
|
||||
- text: ' <code>babbage(99736, 269696)</code> no debe devolver 99736 (hay una respuesta más pequeña).'
|
||||
testString: 'assert.equal(babbage(babbageAns, endDigits), answer, "<code>babbage(99736, 269696)</code> should not return 99736 (there is a smaller answer).");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,20 +6,20 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Determine si una cadena generada de corchetes está equilibrada; es decir, si consiste completamente en pares de paréntesis de apertura / cierre (en ese orden), ninguno de los cuales se equivoca. </p>
|
||||
Ejemplos:
|
||||
<p class='rosetta__paragraph'> (vacío) verdadero </p>
|
||||
<p class='rosetta__paragraph'> <code>[]</code> verdadero </p>
|
||||
<p class='rosetta__paragraph'> <code>][</code> falso </p>
|
||||
<p class='rosetta__paragraph'> <code>[][]</code> verdadero </p>
|
||||
<p class='rosetta__paragraph'> <code>][][</code> falso </p>
|
||||
<p class='rosetta__paragraph'> <code>[]][[]</code> falso </p>
|
||||
<p class='rosetta__paragraph'> <code>[[[[]]]]</code> verdadero </p>
|
||||
<section id='description'>
|
||||
<p> Determine si una cadena generada de corchetes está equilibrada; es decir, si consiste completamente en pares de paréntesis de apertura / cierre (en ese orden), ninguno de los cuales se equivoca. </p>
|
||||
Ejemplos:
|
||||
<p class='rosetta__paragraph'> (vacío) verdadero </p>
|
||||
<p class='rosetta__paragraph'> <code>[]</code> verdadero </p>
|
||||
<p class='rosetta__paragraph'> <code>][</code> falso </p>
|
||||
<p class='rosetta__paragraph'> <code>[][]</code> verdadero </p>
|
||||
<p class='rosetta__paragraph'> <code>][][</code> falso </p>
|
||||
<p class='rosetta__paragraph'> <code>[]][[]</code> falso </p>
|
||||
<p class='rosetta__paragraph'> <code>[[[[]]]]</code> verdadero </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -30,39 +30,39 @@ Ejemplos:
|
||||
tests:
|
||||
- text: <code>isBalanced</code> es una función.
|
||||
testString: 'assert(typeof isBalanced === "function", "<code>isBalanced</code> is a function.");'
|
||||
- text: ' <code>isBalanced("[]")</code> debe devolver verdadero.'
|
||||
- text: ' <code>isBalanced("[]")</code> debe devolver verdadero.'
|
||||
testString: 'assert(isBalanced(testCases[0]), "<code>isBalanced("[]")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("]][[[][][][]][")</code> debe devolver falso.'
|
||||
- text: ' <code>isBalanced("]][[[][][][]][")</code> debe devolver falso.'
|
||||
testString: 'assert(!isBalanced(testCases[1]), "<code>isBalanced("]][[[][][][]][")</code> should return false.");'
|
||||
- text: ' <code>isBalanced("[][[[[][][[[]]]]]]")</code> debe devolver verdadero).
|
||||
- text: ' <code>isBalanced("[][[[[][][[[]]]]]]")</code> debe devolver verdadero).
|
||||
testString: 'assert(isBalanced(testCases[2]), "<code>isBalanced("[][[[[][][[[]]]]]]")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("][")</code> debe devolver verdadero.'
|
||||
- text: ' <code>isBalanced("][")</code> debe devolver verdadero.'
|
||||
testString: 'assert(!isBalanced(testCases[3]), "<code>isBalanced("][")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("[[[]]]][[]")</code> debe devolver verdadero.'
|
||||
- text: ' <code>isBalanced("[[[]]]][[]")</code> debe devolver verdadero.'
|
||||
testString: 'assert(!isBalanced(testCases[4]), "<code>isBalanced("[[[]]]][[]")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("][[]")</code> debe devolver verdadero.'
|
||||
- text: ' <code>isBalanced("][[]")</code> debe devolver verdadero.'
|
||||
testString: 'assert(!isBalanced(testCases[5]), "<code>isBalanced("][[]")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("][[][]][[[]]")</code> debe devolver verdadero.'
|
||||
- text: ' <code>isBalanced("][[][]][[[]]")</code> debe devolver verdadero.'
|
||||
testString: 'assert(!isBalanced(testCases[6]), "<code>isBalanced("][[][]][[[]]")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("[[][]]][")</code> debe devolver verdadero.'
|
||||
- text: ' <code>isBalanced("[[][]]][")</code> debe devolver verdadero.'
|
||||
testString: 'assert(!isBalanced(testCases[7]), "<code>isBalanced("[[][]]][")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("[[[]]][[]]]][][[")</code> debería devolver true.'
|
||||
- text: ' <code>isBalanced("[[[]]][[]]]][][[")</code> debería devolver true.'
|
||||
testString: 'assert(!isBalanced(testCases[8]), "<code>isBalanced("[[[]]][[]]]][][[")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("[]][[]]][[[[][]]")</code> debe devolver verdadero.'
|
||||
- text: ' <code>isBalanced("[]][[]]][[[[][]]")</code> debe devolver verdadero.'
|
||||
testString: 'assert(!isBalanced(testCases[9]), "<code>isBalanced("[]][[]]][[[[][]]")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("][]][[][")</code> debe devolver verdadero.'
|
||||
- text: ' <code>isBalanced("][]][[][")</code> debe devolver verdadero.'
|
||||
testString: 'assert(!isBalanced(testCases[10]), "<code>isBalanced("][]][[][")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("[[]][[][]]")</code> debe devolver verdadero.'
|
||||
- text: ' <code>isBalanced("[[]][[][]]")</code> debe devolver verdadero.'
|
||||
testString: 'assert(isBalanced(testCases[11]), "<code>isBalanced("[[]][[][]]")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("[[]]")</code> debe devolver verdadero.'
|
||||
- text: ' <code>isBalanced("[[]]")</code> debe devolver verdadero.'
|
||||
testString: 'assert(isBalanced(testCases[12]), "<code>isBalanced("[[]]")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("]][]][[]][[[")</code> debe devolver verdadero ".
|
||||
- text: ' <code>isBalanced("]][]][[]][[[")</code> debe devolver verdadero ".
|
||||
testString: 'assert(!isBalanced(testCases[13]), "<code>isBalanced("]][]][[]][[[")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("][]][][[")</code> debería devolver verdadero.'
|
||||
- text: ' <code>isBalanced("][]][][[")</code> debería devolver verdadero.'
|
||||
testString: 'assert(!isBalanced(testCases[14]), "<code>isBalanced("][]][][[")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("][][")</code> debe devolver verdadero.'
|
||||
- text: ' <code>isBalanced("][][")</code> debe devolver verdadero.'
|
||||
testString: 'assert(!isBalanced(testCases[15]), "<code>isBalanced("][][")</code> should return true.");'
|
||||
- text: ' <code>isBalanced("[[]]][][][[]][")</code> debe devolver verdadero.'
|
||||
- text: ' <code>isBalanced("[[]]][][][[]][")</code> debe devolver verdadero.'
|
||||
testString: 'assert(!isBalanced(testCases[16]), "<code>isBalanced("[[]]][][][[]][")</code> should return true.");'
|
||||
- text: <code>isBalanced("")</code> debe devolver true.
|
||||
testString: 'assert(isBalanced(testCases[17]), "<code>isBalanced("")</code> should return true.");'
|
||||
|
||||
@@ -6,33 +6,33 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Dados dos puntos en un plano y un radio, generalmente se pueden dibujar dos círculos de un radio dado a través de los puntos. </p>
|
||||
Excepciones:
|
||||
Un radio de cero debe tratarse como si nunca describiera círculos (excepto en el caso de que los puntos coincidan).
|
||||
Si los puntos son coincidentes, se puede dibujar un número infinito de círculos con el punto en su circunferencia, a menos que el radio también sea igual a cero, lo que luego colapsa los círculos en un punto.
|
||||
Si los puntos forman un diámetro, devuelva un solo círculo.
|
||||
Si los puntos están demasiado separados, no se pueden dibujar círculos. Tarea:
|
||||
Implemente una función que tome dos puntos y un radio y devuelva los dos círculos a través de esos puntos. Para cada círculo resultante, proporcione las coordenadas para el centro de cada círculo redondeado a cuatro dígitos decimales. Devuelve cada coordenada como una matriz y las coordenadas como una matriz de matrices.
|
||||
Para casos de borde, devuelva lo siguiente:
|
||||
Si los puntos están en el diámetro, devuelva un punto. Sin embargo, si el radio también es cero, devuelve <code>"Radius Zero"</code> .
|
||||
Si los puntos coinciden, devuelva <code>"Coincident point. Infinite solutions"</code> .
|
||||
Si los puntos están más separados que el diámetro, regrese <code>"No intersection. Points further apart than circle diameter"</code> .
|
||||
Entradas de muestra:
|
||||
<pre>
|
||||
p1 p2 r
|
||||
0.1234, 0.9876 0.8765, 0.2345 2.0
|
||||
0.0000, 2.0000 0.0000, 0.0000 1.0
|
||||
0.1234, 0.9876 0.1234, 0.9876 2.0
|
||||
0.1234, 0.9876 0.8765, 0.2345 0.5
|
||||
0.1234, 0.9876 0.1234, 0.9876 0.0
|
||||
</pre>
|
||||
Ref:
|
||||
<a href="http://mathforum.org/library/drmath/view/53027.html" title="enlace: http://mathforum.org/library/drmath/view/53027.html">Encontrar el centro de un círculo a partir de 2 puntos y el radio</a> en el foro de Matemáticas @ Drexel
|
||||
<section id='description'>
|
||||
<p> Dados dos puntos en un plano y un radio, generalmente se pueden dibujar dos círculos de un radio dado a través de los puntos. </p>
|
||||
Excepciones:
|
||||
Un radio de cero debe tratarse como si nunca describiera círculos (excepto en el caso de que los puntos coincidan).
|
||||
Si los puntos son coincidentes, se puede dibujar un número infinito de círculos con el punto en su circunferencia, a menos que el radio también sea igual a cero, lo que luego colapsa los círculos en un punto.
|
||||
Si los puntos forman un diámetro, devuelva un solo círculo.
|
||||
Si los puntos están demasiado separados, no se pueden dibujar círculos. Tarea:
|
||||
Implemente una función que tome dos puntos y un radio y devuelva los dos círculos a través de esos puntos. Para cada círculo resultante, proporcione las coordenadas para el centro de cada círculo redondeado a cuatro dígitos decimales. Devuelve cada coordenada como una matriz y las coordenadas como una matriz de matrices.
|
||||
Para casos de borde, devuelva lo siguiente:
|
||||
Si los puntos están en el diámetro, devuelva un punto. Sin embargo, si el radio también es cero, devuelve <code>"Radius Zero"</code> .
|
||||
Si los puntos coinciden, devuelva <code>"Coincident point. Infinite solutions"</code> .
|
||||
Si los puntos están más separados que el diámetro, regrese <code>"No intersection. Points further apart than circle diameter"</code> .
|
||||
Entradas de muestra:
|
||||
<pre>
|
||||
p1 p2 r
|
||||
0.1234, 0.9876 0.8765, 0.2345 2.0
|
||||
0.0000, 2.0000 0.0000, 0.0000 1.0
|
||||
0.1234, 0.9876 0.1234, 0.9876 2.0
|
||||
0.1234, 0.9876 0.8765, 0.2345 0.5
|
||||
0.1234, 0.9876 0.1234, 0.9876 0.0
|
||||
</pre>
|
||||
Ref:
|
||||
<a href="http://mathforum.org/library/drmath/view/53027.html" title="enlace: http://mathforum.org/library/drmath/view/53027.html">Encontrar el centro de un círculo a partir de 2 puntos y el radio</a> en el foro de Matemáticas @ Drexel
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -43,15 +43,15 @@ Ref:
|
||||
tests:
|
||||
- text: <code>getCircles</code> es una función.
|
||||
testString: 'assert(typeof getCircles === "function", "<code>getCircles</code> is a function.");'
|
||||
- text: ' <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> .'
|
||||
- text: ' <code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 2.0)</code> debe devolver <code>[[1.8631, 1.9742], [-0.8632, -0.7521]]</code> .'
|
||||
testString: 'assert.deepEqual(getCircles(...testCases[0]), answers[0], "<code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 2.0)</code> should return <code>[[1.8631, 1.9742], [-0.8632, -0.7521]]</code>.");'
|
||||
- text: ' <code>getCircles([0.0000, 2.0000], [0.0000, 0.0000], 1.0)</code> debe devolver <code>[0, 1]</code> '
|
||||
- text: ' <code>getCircles([0.0000, 2.0000], [0.0000, 0.0000], 1.0)</code> debe devolver <code>[0, 1]</code> '
|
||||
testString: 'assert.deepEqual(getCircles(...testCases[1]), answers[1], "<code>getCircles([0.0000, 2.0000], [0.0000, 0.0000], 1.0)</code> should return <code>[0, 1]</code>");'
|
||||
- text: ' <code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 2.0)</code> debe devolver el <code>Coincident point. Infinite solutions</code> '
|
||||
- text: ' <code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 2.0)</code> debe devolver el <code>Coincident point. Infinite solutions</code> '
|
||||
testString: 'assert.deepEqual(getCircles(...testCases[2]), answers[2], "<code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 2.0)</code> should return <code>Coincident point. Infinite solutions</code>");'
|
||||
- text: ' <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> '
|
||||
- text: ' <code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 0.5)</code> debe devolver <code>No intersection. Points further apart than circle diameter</code> '
|
||||
testString: 'assert.deepEqual(getCircles(...testCases[3]), answers[3], "<code>getCircles([0.1234, 0.9876], [0.8765, 0.2345], 0.5)</code> should return <code>No intersection. Points further apart than circle diameter</code>");'
|
||||
- text: ' <code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 0.0)</code> debe devolver <code>Radius Zero</code> '
|
||||
- text: ' <code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 0.0)</code> debe devolver <code>Radius Zero</code> '
|
||||
testString: 'assert.deepEqual(getCircles(...testCases[4]), answers[4], "<code>getCircles([0.1234, 0.9876], [0.1234, 0.9876], 0.0)</code> should return <code>Radius Zero</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,27 +6,27 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Dado los enteros no negativos <big>m</big> y <big>n</big> , genere todas las <a href="http://mathworld.wolfram.com/Combination.html" title="enlace: http://mathworld.wolfram.com/Combination.html">combinaciones</a> de tamaño <big>m</big> de los enteros de <big>0</big> (cero) a <big>n-1</big> en orden ordenado (cada combinación está ordenada y la tabla completa está ordenada). </p>
|
||||
Ejemplo:
|
||||
<p> <big>3</big> peine <big>5</big> es: </p>
|
||||
<pre>
|
||||
0 1 2
|
||||
0 1 3
|
||||
0 1 4
|
||||
0 2 2
|
||||
0 2 4
|
||||
0 3 4
|
||||
1 2 3
|
||||
1 2 4
|
||||
1 3 4
|
||||
2 3 4
|
||||
</pre>
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Dado los enteros no negativos <big>m</big> y <big>n</big> , genere todas las <a href="http://mathworld.wolfram.com/Combination.html" title="enlace: http://mathworld.wolfram.com/Combination.html">combinaciones</a> de tamaño <big>m</big> de los enteros de <big>0</big> (cero) a <big>n-1</big> en orden ordenado (cada combinación está ordenada y la tabla completa está ordenada). </p>
|
||||
Ejemplo:
|
||||
<p> <big>3</big> peine <big>5</big> es: </p>
|
||||
<pre>
|
||||
0 1 2
|
||||
0 1 3
|
||||
0 1 4
|
||||
0 2 2
|
||||
0 2 4
|
||||
0 3 4
|
||||
1 2 3
|
||||
1 2 4
|
||||
1 3 4
|
||||
2 3 4
|
||||
</pre>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -37,9 +37,9 @@ Ejemplo:
|
||||
tests:
|
||||
- text: <code>combinations</code> son una función.
|
||||
testString: 'assert(typeof combinations === "function", "<code>combinations</code> is a function.");'
|
||||
- text: ' <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> . '
|
||||
- text: ' <code>combinations(3, 5)</code> deben devolver <code>[[0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [0, 3, 4], [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]</code> . '
|
||||
testString: 'assert.deepEqual(combinations(testInput1[0], testInput1[1]), testOutput1, "<code>combinations(3, 5)</code> should return <code>[[0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 2, 3], [0, 2, 4], [0, 3, 4], [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]</code>.");'
|
||||
- text: ' <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> '
|
||||
- text: ' <code>combinations(4, 6)</code> deben devolver <code>[[0,1,2,3], [0,1,2,4], [0,1,2,5], [0,1,3,4], [0,1,3,5], [0,1,4,5], [0,2,3,4], [0,2,3,5], [0,2,4,5], [0,3,4,5], [1,2,3,4], [1,2,3,5], [1,2,4,5], [1,3,4,5], [2,3,4,5]]</code> '
|
||||
testString: 'assert.deepEqual(combinations(testInput2[0], testInput2[1]), testOutput2, "<code>combinations(4, 6)</code> should return <code>[[0,1,2,3], [0,1,2,4], [0,1,2,5], [0,1,3,4], [0,1,3,5], [0,1,4,5], [0,2,3,4], [0,2,3,5], [0,2,4,5], [0,3,4,5], [1,2,3,4], [1,2,3,5], [1,2,4,5], [1,3,4,5], [2,3,4,5]]</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,23 +6,23 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> La objeción de coma es una tarea establecida originalmente por Eric Lippert en su <a href="http://blogs.msdn.com/b/ericlippert/archive/2009/04/15/comma-quibbling.aspx" title="enlace: http://blogs.msdn.com/b/ericlippert/archive/2009/04/15/comma-quibbling.aspx">blog</a> . </p>
|
||||
Tarea: <p> Escriba una función para generar una salida de cadena que sea la concatenación de palabras de entrada de una lista / secuencia donde: </p>
|
||||
Una entrada sin palabras produce la cadena de salida de solo los dos caracteres de refuerzo "{}".
|
||||
Una entrada de una sola palabra, por ejemplo, ["ABC"], produce la cadena de salida de la palabra dentro de las dos llaves, por ejemplo, "{ABC}".
|
||||
Una entrada de dos palabras, por ejemplo, ["ABC", "DEF"], produce la cadena de salida de las dos palabras dentro de las dos llaves con las palabras separadas por la cadena "y", por ejemplo, "{ABC y DEF}".
|
||||
Una entrada de tres o más palabras, por ejemplo, ["ABC", "DEF", "G", "H"], produce la cadena de salida de todos menos la última palabra separada por "," con la última palabra separada por " y "y todo entre llaves; por ejemplo, "{ABC, DEF, G y H}".
|
||||
<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).
|
||||
["ABC"]
|
||||
["ABC", "DEF"]
|
||||
["ABC", "DEF", "G", "H"]
|
||||
<p> Nota: Suponga que las palabras son cadenas no vacías de caracteres en mayúscula para esta tarea. </p>
|
||||
<section id='description'>
|
||||
<p> La objeción de coma es una tarea establecida originalmente por Eric Lippert en su <a href="http://blogs.msdn.com/b/ericlippert/archive/2009/04/15/comma-quibbling.aspx" title="enlace: http://blogs.msdn.com/b/ericlippert/archive/2009/04/15/comma-quibbling.aspx">blog</a> . </p>
|
||||
Tarea: <p> Escriba una función para generar una salida de cadena que sea la concatenación de palabras de entrada de una lista / secuencia donde: </p>
|
||||
Una entrada sin palabras produce la cadena de salida de solo los dos caracteres de refuerzo "{}".
|
||||
Una entrada de una sola palabra, por ejemplo, ["ABC"], produce la cadena de salida de la palabra dentro de las dos llaves, por ejemplo, "{ABC}".
|
||||
Una entrada de dos palabras, por ejemplo, ["ABC", "DEF"], produce la cadena de salida de las dos palabras dentro de las dos llaves con las palabras separadas por la cadena "y", por ejemplo, "{ABC y DEF}".
|
||||
Una entrada de tres o más palabras, por ejemplo, ["ABC", "DEF", "G", "H"], produce la cadena de salida de todos menos la última palabra separada por "," con la última palabra separada por " y "y todo entre llaves; por ejemplo, "{ABC, DEF, G y H}".
|
||||
<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).
|
||||
["ABC"]
|
||||
["ABC", "DEF"]
|
||||
["ABC", "DEF", "G", "H"]
|
||||
<p> Nota: Suponga que las palabras son cadenas no vacías de caracteres en mayúscula para esta tarea. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -33,15 +33,15 @@ Una entrada de tres o más palabras, por ejemplo, ["ABC", "DEF&qu
|
||||
tests:
|
||||
- text: <code>quibble</code> es una función.
|
||||
testString: 'assert(typeof quibble === "function", "<code>quibble</code> is a function.");'
|
||||
- text: ' <code>quibble(["ABC"])</code> debería devolver una cadena.'
|
||||
- text: ' <code>quibble(["ABC"])</code> debería devolver una cadena.'
|
||||
testString: 'assert(typeof quibble(["ABC"]) === "string", "<code>quibble(["ABC"])</code> should return a string.");'
|
||||
- text: ' <code>quibble([])</code> debe devolver "{}".'
|
||||
- text: ' <code>quibble([])</code> debe devolver "{}".'
|
||||
testString: 'assert.equal(quibble(testCases[0]), results[0], "<code>quibble([])</code> should return "{}".");'
|
||||
- text: ' <code>quibble(["ABC"])</code> debe devolver "{ABC}".'
|
||||
- text: ' <code>quibble(["ABC"])</code> debe devolver "{ABC}".'
|
||||
testString: 'assert.equal(quibble(testCases[1]), results[1], "<code>quibble(["ABC"])</code> should return "{ABC}".");'
|
||||
- text: ' <code>quibble(["ABC", "DEF"])</code> debe devolver "{ABC and DEF}".'
|
||||
- text: ' <code>quibble(["ABC", "DEF"])</code> debe devolver "{ABC and DEF}".'
|
||||
testString: 'assert.equal(quibble(testCases[2]), results[2], "<code>quibble(["ABC", "DEF"])</code> should return "{ABC and DEF}".");'
|
||||
- text: ' <code>quibble(["ABC", "DEF", "G", "H"])</code> debe devolver "{ABC, DEF, G y H}".'
|
||||
- text: ' <code>quibble(["ABC", "DEF", "G", "H"])</code> debe devolver "{ABC, DEF, G y H}".'
|
||||
testString: 'assert.equal(quibble(testCases[3]), results[3], "<code>quibble(["ABC", "DEF", "G", "H"])</code> should return "{ABC,DEF,G and H}".");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,13 +6,13 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Dada una <a href="https://en.wikipedia.org/wiki/List_(abstract_data_type)" title="wp: List_ (abstract_data_type)">lista</a> de muchas cadenas arbitrarias, implemente una función para cada una de las siguientes condiciones: </p> prueba si todos son léxicamente iguales
|
||||
prueba si cada cadena es léxicamente menor que la siguiente (es decir, si la lista está en estricto orden ascendente)
|
||||
<section id='description'>
|
||||
<p> Dada una <a href="https://en.wikipedia.org/wiki/List_(abstract_data_type)" title="wp: List_ (abstract_data_type)">lista</a> de muchas cadenas arbitrarias, implemente una función para cada una de las siguientes condiciones: </p> prueba si todos son léxicamente iguales
|
||||
prueba si cada cadena es léxicamente menor que la siguiente (es decir, si la lista está en estricto orden ascendente)
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -25,25 +25,25 @@ tests:
|
||||
testString: 'assert(typeof allEqual === "function", "<code>allEqual</code> is a function.");'
|
||||
- text: <code>azSorted</code> es una función.
|
||||
testString: 'assert(typeof azSorted === "function", "<code>azSorted</code> is a function.");'
|
||||
- text: ' <code>allEqual(["AA", "AA", "AA", "AA"])</code> devuelve true.'
|
||||
- text: ' <code>allEqual(["AA", "AA", "AA", "AA"])</code> devuelve true.'
|
||||
testString: 'assert(allEqual(testCases[0]), "<code>allEqual(["AA", "AA", "AA", "AA"])</code> returns true.");'
|
||||
- text: ' <code>azSorted(["AA", "AA", "AA", "AA"])</code> devuelve falso.'
|
||||
- text: ' <code>azSorted(["AA", "AA", "AA", "AA"])</code> devuelve falso.'
|
||||
testString: 'assert(!azSorted(testCases[0]), "<code>azSorted(["AA", "AA", "AA", "AA"])</code> returns false.");'
|
||||
- text: ' <code>allEqual(["AA", "ACB", "BB", "CC"])</code> devuelve falso.'
|
||||
- text: ' <code>allEqual(["AA", "ACB", "BB", "CC"])</code> devuelve falso.'
|
||||
testString: 'assert(!allEqual(testCases[1]), "<code>allEqual(["AA", "ACB", "BB", "CC"])</code> returns false.");'
|
||||
- text: ' <code>azSorted(["AA", "ACB", "BB", "CC"])</code> devuelve verdadero.'
|
||||
- text: ' <code>azSorted(["AA", "ACB", "BB", "CC"])</code> devuelve verdadero.'
|
||||
testString: 'assert(azSorted(testCases[1]), "<code>azSorted(["AA", "ACB", "BB", "CC"])</code> returns true.");'
|
||||
- text: ' <code>allEqual([])</code> devuelve true.'
|
||||
- text: ' <code>allEqual([])</code> devuelve true.'
|
||||
testString: 'assert(allEqual(testCases[2]), "<code>allEqual([])</code> returns true.");'
|
||||
- text: ' <code>azSorted([])</code> devuelve true.'
|
||||
- text: ' <code>azSorted([])</code> devuelve true.'
|
||||
testString: 'assert(azSorted(testCases[2]), "<code>azSorted([])</code> returns true.");'
|
||||
- text: ' <code>allEqual(["AA"])</code> devuelve true.'
|
||||
- text: ' <code>allEqual(["AA"])</code> devuelve true.'
|
||||
testString: 'assert(allEqual(testCases[3]), "<code>allEqual(["AA"])</code> returns true.");'
|
||||
- text: ' <code>azSorted(["AA"])</code> devuelve verdadero.'
|
||||
- text: ' <code>azSorted(["AA"])</code> devuelve verdadero.'
|
||||
testString: 'assert(azSorted(testCases[3]), "<code>azSorted(["AA"])</code> returns true.");'
|
||||
- text: ' <code>allEqual(["BB", "AA"])</code> devuelve false. "
|
||||
- text: ' <code>allEqual(["BB", "AA"])</code> devuelve false. "
|
||||
testString: 'assert(!allEqual(testCases[4]), "<code>allEqual(["BB", "AA"])</code> returns false.");'
|
||||
- text: ' <code>azSorted(["BB", "AA"])</code> devuelve falso.'
|
||||
- text: ' <code>azSorted(["BB", "AA"])</code> devuelve falso.'
|
||||
testString: 'assert(!azSorted(testCases[4]), "<code>azSorted(["BB", "AA"])</code> returns false.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,74 +6,74 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Implementar una función que: </p>
|
||||
toma un entero positivo que representa una duración en segundos como entrada (por ejemplo, <code>100</code> ), y
|
||||
devuelve una cadena que muestra la misma duración descompuesta en semanas, días, horas, minutos y segundos como se detalla a continuación (por ejemplo, " <code>1 min, 40 sec</code> ").
|
||||
<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 " <code>1 d</code> " y no " <code>0 wk, 1 d, 0 hr, 0 min, 0 sec</code> "). Dé prioridad a las unidades más grandes sobre las más pequeñas como tanto como sea posible (p. ej., devuelva <code>2 min, 10 sec</code> y no <code>1 min, 70 sec</code> o <code>130 sec</code> ) Imite el formato que se muestra en los casos de prueba (cantidades ordenadas de unidad mayor a menor y separadas por comas + espacio; valor y unidad de cada cantidad separada por espacio).
|
||||
<p><hr style="margin:1em 0;"/></p>
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Implementar una función que: </p>
|
||||
toma un entero positivo que representa una duración en segundos como entrada (por ejemplo, <code>100</code> ), y
|
||||
devuelve una cadena que muestra la misma duración descompuesta en semanas, días, horas, minutos y segundos como se detalla a continuación (por ejemplo, " <code>1 min, 40 sec</code> ").
|
||||
<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 " <code>1 d</code> " y no " <code>0 wk, 1 d, 0 hr, 0 min, 0 sec</code> "). Dé prioridad a las unidades más grandes sobre las más pequeñas como tanto como sea posible (p. ej., devuelva <code>2 min, 10 sec</code> y no <code>1 min, 70 sec</code> o <code>130 sec</code> ) Imite el formato que se muestra en los casos de prueba (cantidades ordenadas de unidad mayor a menor y separadas por comas + espacio; valor y unidad de cada cantidad separada por espacio).
|
||||
<p><hr style="margin:1em 0;"/></p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -84,11 +84,11 @@ Sin embargo, solo incluya cantidades con valores que no sean cero en la salida (
|
||||
tests:
|
||||
- text: <code>convertSeconds</code> es una función.
|
||||
testString: 'assert(typeof convertSeconds === "function", "<code>convertSeconds</code> is a function.");'
|
||||
- text: ' <code>convertSeconds(7259)</code> debe devolver <code>2 hr, 59 sec</code> .'
|
||||
- text: ' <code>convertSeconds(7259)</code> debe devolver <code>2 hr, 59 sec</code> .'
|
||||
testString: 'assert.equal(convertSeconds(testCases[0]), results[0], "<code>convertSeconds(7259)</code> should return <code>2 hr, 59 sec</code>.");'
|
||||
- text: <code>convertSeconds(86400)</code> debe devolver <code>1 d</code> .
|
||||
testString: 'assert.equal(convertSeconds(testCases[1]), results[1], "<code>convertSeconds(86400)</code> should return <code>1 d</code>.");'
|
||||
- text: ' <code>convertSeconds(6000000)</code> debe devolver <code>9 wk, 6 d, 10 hr, 40 min</code> .'
|
||||
- text: ' <code>convertSeconds(6000000)</code> debe devolver <code>9 wk, 6 d, 10 hr, 40 min</code> .'
|
||||
testString: 'assert.equal(convertSeconds(testCases[2]), results[2], "<code>convertSeconds(6000000)</code> should return <code>9 wk, 6 d, 10 hr, 40 min</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,17 +6,17 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Cree una función, o muestre una función incorporada, para contar el número de apariciones no superpuestas de una subcadena dentro de una cadena. </p><p> La función debe tomar dos argumentos: </p>
|
||||
el primer argumento es la cadena a buscar, y
|
||||
el segundo una subcadena a buscar.
|
||||
<p> Debe devolver un número entero. </p>
|
||||
<p> La coincidencia debe producir el mayor número de coincidencias no superpuestas. </p><p> En general, esto significa esencialmente hacer coincidir de izquierda a derecha o de derecha a izquierda. </p>
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Cree una función, o muestre una función incorporada, para contar el número de apariciones no superpuestas de una subcadena dentro de una cadena. </p><p> La función debe tomar dos argumentos: </p>
|
||||
el primer argumento es la cadena a buscar, y
|
||||
el segundo una subcadena a buscar.
|
||||
<p> Debe devolver un número entero. </p>
|
||||
<p> La coincidencia debe producir el mayor número de coincidencias no superpuestas. </p><p> En general, esto significa esencialmente hacer coincidir de izquierda a derecha o de derecha a izquierda. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -27,11 +27,11 @@ el segundo una subcadena a buscar.
|
||||
tests:
|
||||
- text: <code>countSubstring</code> es una función.
|
||||
testString: 'assert(typeof countSubstring === "function", "<code>countSubstring</code> is a function.");'
|
||||
- text: ' <code>countSubstring("the three truths", "th")</code> debe devolver <code>3</code> '
|
||||
- text: ' <code>countSubstring("the three truths", "th")</code> debe devolver <code>3</code> '
|
||||
testString: 'assert.equal(countSubstring(testCases[0], searchString[0]), results[0], "<code>countSubstring("the three truths", "th")</code> should return <code>3</code>.");'
|
||||
- text: ' <code>countSubstring("ababababab", "abab")</code> debe devolver <code>2</code> '
|
||||
- text: ' <code>countSubstring("ababababab", "abab")</code> debe devolver <code>2</code> '
|
||||
testString: 'assert.equal(countSubstring(testCases[1], searchString[1]), results[1], "<code>countSubstring("ababababab", "abab")</code> should return <code>2</code>.");'
|
||||
- text: ' <code>countSubstring("abaabba*bbaba*bbab", "a*b")</code> debe devolver <code>2</code> '
|
||||
- text: ' <code>countSubstring("abaabba*bbaba*bbab", "a*b")</code> debe devolver <code>2</code> '
|
||||
testString: 'assert.equal(countSubstring(testCases[2], searchString[2]), results[2], "<code>countSubstring("abaabba*bbaba*bbab", "a*b")</code> should return <code>2</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,29 +6,29 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> En <a href="https://en.wikipedia.org/wiki/linear algebra" title="wp: álgebra lineal">álgebra lineal</a> , <a href="https://en.wikipedia.org/wiki/Cramer's rule" title="wp: la regla de cramer">la regla de Cramer</a> es una fórmula explícita para la solución de un <a href="https://en.wikipedia.org/wiki/system of linear equations" title="wp: sistema de ecuaciones lineales">sistema de ecuaciones lineales</a> con tantas ecuaciones como incógnitas, válida siempre que el sistema tenga una solución única. Expresa la solución en términos de los determinantes de la matriz del coeficiente (cuadrado) y de las matrices obtenidas de ella al reemplazar una columna por el vector de los lados derechos de las ecuaciones. </p>
|
||||
<p> Dado </p>
|
||||
<p> </p>
|
||||
<p> $ \ left \ {\ begin {matrix} a_1x + b_1y + c_1z & = {\ color {red} d_1} \\ a_2x + b_2y + c_2z & = {\ color {red} d_2} \\ a_3x + b_3y + c_3z & = {\ color {rojo} d_3} \ fin {matriz} \ derecha. $ </p>
|
||||
<p> que en formato matricial es </p><p></p>
|
||||
<p> $ \ begin {bmatrix} a_1 & b_1 & c_1 \\ a_2 & b_2 & c_2 \\ a_3 & b_3 & 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} & b_1 & c_1 \\ {\ color {red} d_2} & b_2 & c_2 \\ {\ color {red} d_3} & b_3 & c_3 \ end {vmatrix}} {\ begin {vmatrix} a_1 & b_1 & c_1 \\ a_2 & b_2 & c_2 \\ a_3 & b_3 & c_3 \ end {vmatrix}}, \ quad y = \ frac {\ begin {vmatrix } a_1 & {\ color {red} d_1} & c_1 \\ a_2 & {\ color {red} d_2} & c_2 \\ a_3 & {\ color {red} d_3} & c_3 \ end {vmatrix}} {\ comenzar {vmatrix} a_1 & b_1 & c_1 \\ a_2 & b_2 & c_2 \\ a_3 & b_3 & c_3 \ end {vmatrix}}, \ text {and} z = \ frac {\ begin {vmatrix} a_1 & b_1 & {\ color {rojo} d_1} \\ a_2 & b_2 & {\ color {red} d_2} \\ a_3 & b_3 & {\ color {rojo} d_3} \ end {vmatrix}} {\ begin {vmatrix} a_1 & b_1 & c_1 \\ a_2 & b_2 & c_2 \\ a_3 & b_3 & c_3 \ end {vmatrix}}. $ </p>
|
||||
<section id='description'>
|
||||
<p> En <a href="https://en.wikipedia.org/wiki/linear algebra" title="wp: álgebra lineal">álgebra lineal</a> , <a href="https://en.wikipedia.org/wiki/Cramer's rule" title="wp: la regla de cramer">la regla de Cramer</a> es una fórmula explícita para la solución de un <a href="https://en.wikipedia.org/wiki/system of linear equations" title="wp: sistema de ecuaciones lineales">sistema de ecuaciones lineales</a> con tantas ecuaciones como incógnitas, válida siempre que el sistema tenga una solución única. Expresa la solución en términos de los determinantes de la matriz del coeficiente (cuadrado) y de las matrices obtenidas de ella al reemplazar una columna por el vector de los lados derechos de las ecuaciones. </p>
|
||||
<p> Dado </p>
|
||||
<p> </p>
|
||||
<p> $ \ left \ {\ begin {matrix} a_1x + b_1y + c_1z & = {\ color {red} d_1} \\ a_2x + b_2y + c_2z & = {\ color {red} d_2} \\ a_3x + b_3y + c_3z & = {\ color {rojo} d_3} \ fin {matriz} \ derecha. $ </p>
|
||||
<p> que en formato matricial es </p><p></p>
|
||||
<p> $ \ begin {bmatrix} a_1 & b_1 & c_1 \\ a_2 & b_2 & c_2 \\ a_3 & b_3 & 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} & b_1 & c_1 \\ {\ color {red} d_2} & b_2 & c_2 \\ {\ color {red} d_3} & b_3 & c_3 \ end {vmatrix}} {\ begin {vmatrix} a_1 & b_1 & c_1 \\ a_2 & b_2 & c_2 \\ a_3 & b_3 & c_3 \ end {vmatrix}}, \ quad y = \ frac {\ begin {vmatrix } a_1 & {\ color {red} d_1} & c_1 \\ a_2 & {\ color {red} d_2} & c_2 \\ a_3 & {\ color {red} d_3} & c_3 \ end {vmatrix}} {\ comenzar {vmatrix} a_1 & b_1 & c_1 \\ a_2 & b_2 & c_2 \\ a_3 & b_3 & c_3 \ end {vmatrix}}, \ text {and} z = \ frac {\ begin {vmatrix} a_1 & b_1 & {\ color {rojo} d_1} \\ a_2 & b_2 & {\ color {red} d_2} \\ a_3 & b_3 & {\ color {rojo} d_3} \ end {vmatrix}} {\ begin {vmatrix} a_1 & b_1 & c_1 \\ a_2 & b_2 & c_2 \\ a_3 & b_3 & c_3 \ end {vmatrix}}. $ </p>
|
||||
|
||||
Tarea
|
||||
Tarea
|
||||
<p> Dado el siguiente sistema de ecuaciones: </p><p> <big>
|
||||
$ \ begin {cases}
|
||||
2w-x + 5y + z = -3 \\
|
||||
3w + 2x + 2y-6z = -32 \\
|
||||
w + 3x + 3y-z = -47 \\
|
||||
5w-2x -3y + 3z = 49 \\
|
||||
\ fin {casos} $ <code>0</code></big> </p>
|
||||
<p> resuelve por <big>$ w $, $ x $, $ y $</big> y <big>$ z $</big> , usando la regla de Cramer. </p>
|
||||
$ \ begin {cases}
|
||||
2w-x + 5y + z = -3 \\
|
||||
3w + 2x + 2y-6z = -32 \\
|
||||
w + 3x + 3y-z = -47 \\
|
||||
5w-2x -3y + 3z = 49 \\
|
||||
\ fin {casos} $ <code>0</code></big> </p>
|
||||
<p> resuelve por <big>$ w $, $ x $, $ y $</big> y <big>$ z $</big> , usando la regla de Cramer. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -39,9 +39,9 @@ w + 3x + 3y-z = -47 \\
|
||||
tests:
|
||||
- text: <code>cramersRule</code> es una función.
|
||||
testString: 'assert(typeof cramersRule === "function", "<code>cramersRule</code> is a function.");'
|
||||
- text: ' <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> . '
|
||||
- text: ' <code>cramersRule([[2, -1, 5, 1], [3, 2, 2, -6], [1, 3, 3, -1], [5, -2, -3, 3]], [-3, -32, -47, 49])</code> debe devolver <code>[2, -12, -4, 1]</code> . '
|
||||
testString: 'assert.deepEqual(cramersRule(matrices[0], freeTerms[0]), answers[0], "<code>cramersRule([[2, -1, 5, 1], [3, 2, 2, -6], [1, 3, 3, -1], [5, -2, -3, 3]], [-3, -32, -47, 49])</code> should return <code>[2, -12, -4, 1]</code>.");'
|
||||
- text: ' <code>cramersRule([[3, 1, 1], [2, 2, 5], [1, -3, -4]], [3, -1, 2])</code> debe devolver <code>[1, 1, -1]</code> .
|
||||
- text: ' <code>cramersRule([[3, 1, 1], [2, 2, 5], [1, -3, -4]], [3, -1, 2])</code> debe devolver <code>[1, 1, -1]</code> .
|
||||
testString: 'assert.deepEqual(cramersRule(matrices[1], freeTerms[1]), answers[1], "<code>cramersRule([[3, 1, 1], [2, 2, 5], [1, -3, -4]], [3, -1, 2])</code> should return <code>[1, 1, -1]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Dada una cadena de fecha en EST, genera la fecha dada como una cadena con 12 horas agregadas a la hora. </p>
|
||||
<p> La zona horaria debe ser preservada. </p>
|
||||
<p> Ejemplo de entrada: </p>
|
||||
<p> <code>"March 7 2009 7:30pm EST"</code> </p>
|
||||
<p> Ejemplo de salida: </p>
|
||||
<p> <code>"March 8 2009 7:30am EST"</code> </p>
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Dada una cadena de fecha en EST, genera la fecha dada como una cadena con 12 horas agregadas a la hora. </p>
|
||||
<p> La zona horaria debe ser preservada. </p>
|
||||
<p> Ejemplo de entrada: </p>
|
||||
<p> <code>"March 7 2009 7:30pm EST"</code> </p>
|
||||
<p> Ejemplo de salida: </p>
|
||||
<p> <code>"March 8 2009 7:30am EST"</code> </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -30,15 +30,15 @@ tests:
|
||||
testString: 'assert(typeof add12Hours === "function", "<code>add12Hours</code> is a function.");'
|
||||
- text: <code>add12Hours(dateString)</code> debe devolver una cadena.
|
||||
testString: 'assert(typeof add12Hours(tests[0]) === "string", "<code>add12Hours(dateString)</code> should return a string.");'
|
||||
- text: ' <code>add12Hours("" + tests[0] + "")</code> debe devolver <code>"" + answers[0] + ""</code> '
|
||||
- text: ' <code>add12Hours("" + tests[0] + "")</code> debe devolver <code>"" + answers[0] + ""</code> '
|
||||
testString: 'assert(add12Hours(tests[0]) === answers[0], "<code>add12Hours("" + tests[0] + "")</code> should return <code>"" + answers[0] + ""</code>");'
|
||||
- text: Debería cambiar el día. <code>add12Hours("" + tests[1] + "")</code> debe devolver <code>"" + answers[1] + ""</code> '
|
||||
- text: Debería cambiar el día. <code>add12Hours("" + tests[1] + "")</code> debe devolver <code>"" + answers[1] + ""</code> '
|
||||
testString: 'assert(add12Hours(tests[1]) === answers[1], "Should handel day change. <code>add12Hours("" + tests[1] + "")</code> should return <code>"" + answers[1] + ""</code>");'
|
||||
- text: 'Debe cambiar el mes en un año bisiesto. <code>add12Hours("" + tests[2] + "")</code> debe devolver <code>"" + answers[2] + ""</code> '
|
||||
- text: 'Debe cambiar el mes en un año bisiesto. <code>add12Hours("" + tests[2] + "")</code> debe devolver <code>"" + answers[2] + ""</code> '
|
||||
testString: 'assert(add12Hours(tests[2]) === answers[2], "Should handel month change in a leap years. <code>add12Hours("" + tests[2] + "")</code> should return <code>"" + answers[2] + ""</code>");'
|
||||
- text: 'Debería cambiar el mes en un año común. <code>add12Hours("" + tests[3] + "")</code> debe devolver <code>"" + answers[3] + ""</code> '
|
||||
- text: 'Debería cambiar el mes en un año común. <code>add12Hours("" + tests[3] + "")</code> debe devolver <code>"" + answers[3] + ""</code> '
|
||||
testString: 'assert(add12Hours(tests[3]) === answers[3], "Should handel month change in a common years. <code>add12Hours("" + tests[3] + "")</code> should return <code>"" + answers[3] + ""</code>");'
|
||||
- text: Debería cambiar de año. <code>add12Hours("" + tests[4] + "")</code> debe devolver <code>"" + answers[4] + ""</code> '
|
||||
- text: Debería cambiar de año. <code>add12Hours("" + tests[4] + "")</code> debe devolver <code>"" + answers[4] + ""</code> '
|
||||
testString: 'assert(add12Hours(tests[4]) === answers[4], "Should handel year change. <code>add12Hours("" + tests[4] + "")</code> should return <code>"" + answers[4] + ""</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Una empresa decide que cada vez que caiga un domingo en Navidad, les dará a sus trabajadores todos los días feriados extra pagados para que, junto con los días festivos, los trabajadores no tengan que trabajar la semana siguiente (entre el 25 de diciembre y el primero de enero). </p>
|
||||
<p> Tarea: </p>
|
||||
<p> Escriba una función que tome un año de inicio y un año de finalización y devuelva un conjunto de todos los años en los que el 25 de diciembre será un domingo. </p>
|
||||
<section id='description'>
|
||||
<p> Una empresa decide que cada vez que caiga un domingo en Navidad, les dará a sus trabajadores todos los días feriados extra pagados para que, junto con los días festivos, los trabajadores no tengan que trabajar la semana siguiente (entre el 25 de diciembre y el primero de enero). </p>
|
||||
<p> Tarea: </p>
|
||||
<p> Escriba una función que tome un año de inicio y un año de finalización y devuelva un conjunto de todos los años en los que el 25 de diciembre será un domingo. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -24,11 +24,11 @@ challengeType: 5
|
||||
tests:
|
||||
- text: <code>findXmasSunday</code> es una función.
|
||||
testString: 'assert(typeof findXmasSunday === "function", "<code>findXmasSunday</code> is a function.");'
|
||||
- text: ' <code>findChristmasSunday(2000, 2100)</code> debería devolver una matriz.'
|
||||
- text: ' <code>findChristmasSunday(2000, 2100)</code> debería devolver una matriz.'
|
||||
testString: 'assert(typeof findXmasSunday(2000, 2100) === "object", "<code>findChristmasSunday(2000, 2100)</code> should return an array.");'
|
||||
- text: ' <code>findChristmasSunday(2008, 2121</code> debe devolver [1977, 1983, 1988, 1994, 2005, 2011, 2016]'
|
||||
- text: ' <code>findChristmasSunday(2008, 2121</code> debe devolver [1977, 1983, 1988, 1994, 2005, 2011, 2016]'
|
||||
testString: 'assert.deepEqual(findXmasSunday(1970, 2017), firstSolution, "<code>findChristmasSunday(2008, 2121</code> should return [1977, 1983, 1988, 1994, 2005, 2011, 2016]");'
|
||||
- text: ' <code>findChristmasSunday(2008, 2121</code> debe devolver [2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118]'
|
||||
- text: ' <code>findChristmasSunday(2008, 2121</code> debe devolver [2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118]'
|
||||
testString: 'assert.deepEqual(findXmasSunday(2008, 2121), secondSolution, "<code>findChristmasSunday(2008, 2121</code> should return [2011, 2016, 2022, 2033, 2039, 2044, 2050, 2061, 2067, 2072, 2078, 2089, 2095, 2101, 2107, 2112, 2118]");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,59 +6,59 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Free Cell es el juego de cartas solitario que Paul Alfille introdujo al sistema PLATO en 1978. Jim Horne, de Microsoft, cambió el nombre a FreeCell y reimplementó el juego para <a href="http://rosettacode.org/wiki/DOS" title="DOS">DOS</a> , luego <a href="http://rosettacode.org/wiki/Windows" title="Windows">Windows</a> . </p>
|
||||
<p> Esta versión introdujo 32000 ofertas numeradas. (Las <a href="http://www.solitairelaboratory.com/fcfaq.html" title="enlace: http://www.solitairelaboratory.com/fcfaq.html">preguntas frecuentes de FreeCell</a> cuentan esta historia). </p><p> A medida que el juego se hizo popular, Jim Horne reveló <a href="http://www.solitairelaboratory.com/mshuffle.txt" title="enlace: http://www.solitairelaboratory.com/mshuffle.txt">el algoritmo</a> y otras implementaciones de FreeCell comenzaron a reproducir los acuerdos de Microsoft. </p>
|
||||
<p> Estas ofertas están numeradas del 1 al 32000. </p>
|
||||
<p> Las versiones más nuevas de Microsoft tienen 1 millón de ofertas, numeradas del 1 al 1000000; Algunas implementaciones permiten números fuera de ese rango. </p><p> El algoritmo utiliza este <a href="http://rosettacode.org/wiki/linear congruential generator" title="generador lineal congruente">generador lineal congruente</a> de Microsoft C: </p> $ state_ {n + 1} \ equiv 214013 \ times state_n + 2531011 \ pmod {2 ^ {31}} $
|
||||
$ rand_n = state_n \ div 2 ^ {16} $
|
||||
$ rand_n $ está en el rango de 0 a 32767.
|
||||
<p> El algoritmo sigue: </p> Siembra el RNG con el número de la oferta.
|
||||
Crea una <a href="http://rosettacode.org/wiki/array" title="formación">serie</a> de 52 cartas: As of Clubs, As of Diamonds, As of Hearts, As of Spades, 2 of Clubs, 2 of Diamonds, y así sucesivamente a través de las filas: As, 2, 3, 4, 5, 6 , 7, 8, 9, 10, Jack, reina, rey. Los índices de matriz son de 0 a 51, con Ace of Clubs en 0 y King of Spades en 51.
|
||||
Hasta que la matriz esté vacía:
|
||||
Elija una tarjeta al azar en el índice ≡ siguiente número aleatorio (mod longitud de la matriz).
|
||||
Intercambia esta carta aleatoria con la última carta de la matriz.
|
||||
Eliminar esta tarjeta aleatoria de la matriz. (La longitud de la matriz se reduce en 1.)
|
||||
Repartir esta carta aleatoria.
|
||||
Reparte las 52 cartas, boca arriba, en 8 columnas. Las primeras 8 cartas van en 8 columnas, las siguientes 8 cartas van en las primeras 8 cartas, y así sucesivamente.
|
||||
Ejemplo:
|
||||
<p> Orden para repartir cartas </p>
|
||||
<p> <pre> 1 2 3 4 5 6 7 8
|
||||
9 10 11 12 13 14 15 16
|
||||
17 18 19 20 21 22 23 24
|
||||
25 26 27 28 29 30 31 32
|
||||
33 34 35 36 37 38 39 40
|
||||
41 42 43 44 45 46 47 48
|
||||
49 50 51 52 </pre></p>
|
||||
<p> Juego # 1 </p>
|
||||
<p> <pre> [
|
||||
['JD', '2D', '9H', 'JC', '5D', '7H', '7C', '5H'],
|
||||
['KD', 'KC', '9S', '5S', 'AD', 'QC', 'KH', '3H'],
|
||||
['2S', 'KS', '9D', 'QD', 'JS', 'AS', 'AH' , '3C'],
|
||||
['4C', '5C', 'TS', 'QH', '4H', 'AC', '4D', '7S'],
|
||||
['3S', 'TD' , '4S', 'TH', '8H', '2C', 'JH', '7D'],
|
||||
['6D', '8S', '8D', 'QS', '6C', '3D ',' 8C ',' TC '],
|
||||
[' 6S ',' 9C ',' 2H ',' 6H ']
|
||||
] </pre></p>
|
||||
<p> Juego # 617 </p>
|
||||
<p> <pre> [
|
||||
['7D', 'AD', '5C', '3S', '5S', '8C', '2D', 'AH'],
|
||||
['TD', '7S', 'QD', 'AC', '6D', '8H', 'AS', 'KH'],
|
||||
['TH', 'QC', '3H', '9D', '6S', '8D', '3D' , 'TC'],
|
||||
['KD', '5H', '9S', '3C', '8S', '7H', '4D', 'JS'],
|
||||
['4C', 'QS' , '9C', '9H', '7C', '6H', '2C', '2S'],
|
||||
['4S', 'TS', '2H', '5D', 'JC', '6C ',' JH ',' QH '],
|
||||
[' JD ',' KS ',' KC ',' 4H ']
|
||||
] </pre></p>
|
||||
Tarea:
|
||||
<p> Escriba una función para tomar un número de acuerdo y tarjetas de acuerdo en el mismo orden que este algoritmo. </p>
|
||||
<p> La función debe devolver una matriz bidimensional que representa la placa FreeCell. </p>
|
||||
<p> Las ofertas también pueden <a href="http://freecellgamesolutions.com/" title="enlace: http://freecellgamesolutions.com/">compararse con las soluciones FreeCell para 1000000 juegos</a> . </p>
|
||||
<p> (Invoca una solución de video y muestra el trato inicial.) </p>
|
||||
<section id='description'>
|
||||
<p> Free Cell es el juego de cartas solitario que Paul Alfille introdujo al sistema PLATO en 1978. Jim Horne, de Microsoft, cambió el nombre a FreeCell y reimplementó el juego para <a href="http://rosettacode.org/wiki/DOS" title="DOS">DOS</a> , luego <a href="http://rosettacode.org/wiki/Windows" title="Windows">Windows</a> . </p>
|
||||
<p> Esta versión introdujo 32000 ofertas numeradas. (Las <a href="http://www.solitairelaboratory.com/fcfaq.html" title="enlace: http://www.solitairelaboratory.com/fcfaq.html">preguntas frecuentes de FreeCell</a> cuentan esta historia). </p><p> A medida que el juego se hizo popular, Jim Horne reveló <a href="http://www.solitairelaboratory.com/mshuffle.txt" title="enlace: http://www.solitairelaboratory.com/mshuffle.txt">el algoritmo</a> y otras implementaciones de FreeCell comenzaron a reproducir los acuerdos de Microsoft. </p>
|
||||
<p> Estas ofertas están numeradas del 1 al 32000. </p>
|
||||
<p> Las versiones más nuevas de Microsoft tienen 1 millón de ofertas, numeradas del 1 al 1000000; Algunas implementaciones permiten números fuera de ese rango. </p><p> El algoritmo utiliza este <a href="http://rosettacode.org/wiki/linear congruential generator" title="generador lineal congruente">generador lineal congruente</a> de Microsoft C: </p> $ state_ {n + 1} \ equiv 214013 \ times state_n + 2531011 \ pmod {2 ^ {31}} $
|
||||
$ rand_n = state_n \ div 2 ^ {16} $
|
||||
$ rand_n $ está en el rango de 0 a 32767.
|
||||
<p> El algoritmo sigue: </p> Siembra el RNG con el número de la oferta.
|
||||
Crea una <a href="http://rosettacode.org/wiki/array" title="formación">serie</a> de 52 cartas: As of Clubs, As of Diamonds, As of Hearts, As of Spades, 2 of Clubs, 2 of Diamonds, y así sucesivamente a través de las filas: As, 2, 3, 4, 5, 6 , 7, 8, 9, 10, Jack, reina, rey. Los índices de matriz son de 0 a 51, con Ace of Clubs en 0 y King of Spades en 51.
|
||||
Hasta que la matriz esté vacía:
|
||||
Elija una tarjeta al azar en el índice ≡ siguiente número aleatorio (mod longitud de la matriz).
|
||||
Intercambia esta carta aleatoria con la última carta de la matriz.
|
||||
Eliminar esta tarjeta aleatoria de la matriz. (La longitud de la matriz se reduce en 1.)
|
||||
Repartir esta carta aleatoria.
|
||||
Reparte las 52 cartas, boca arriba, en 8 columnas. Las primeras 8 cartas van en 8 columnas, las siguientes 8 cartas van en las primeras 8 cartas, y así sucesivamente.
|
||||
Ejemplo:
|
||||
<p> Orden para repartir cartas </p>
|
||||
<p> <pre> 1 2 3 4 5 6 7 8
|
||||
9 10 11 12 13 14 15 16
|
||||
17 18 19 20 21 22 23 24
|
||||
25 26 27 28 29 30 31 32
|
||||
33 34 35 36 37 38 39 40
|
||||
41 42 43 44 45 46 47 48
|
||||
49 50 51 52 </pre></p>
|
||||
<p> Juego # 1 </p>
|
||||
<p> <pre> [
|
||||
['JD', '2D', '9H', 'JC', '5D', '7H', '7C', '5H'],
|
||||
['KD', 'KC', '9S', '5S', 'AD', 'QC', 'KH', '3H'],
|
||||
['2S', 'KS', '9D', 'QD', 'JS', 'AS', 'AH' , '3C'],
|
||||
['4C', '5C', 'TS', 'QH', '4H', 'AC', '4D', '7S'],
|
||||
['3S', 'TD' , '4S', 'TH', '8H', '2C', 'JH', '7D'],
|
||||
['6D', '8S', '8D', 'QS', '6C', '3D ',' 8C ',' TC '],
|
||||
[' 6S ',' 9C ',' 2H ',' 6H ']
|
||||
] </pre></p>
|
||||
<p> Juego # 617 </p>
|
||||
<p> <pre> [
|
||||
['7D', 'AD', '5C', '3S', '5S', '8C', '2D', 'AH'],
|
||||
['TD', '7S', 'QD', 'AC', '6D', '8H', 'AS', 'KH'],
|
||||
['TH', 'QC', '3H', '9D', '6S', '8D', '3D' , 'TC'],
|
||||
['KD', '5H', '9S', '3C', '8S', '7H', '4D', 'JS'],
|
||||
['4C', 'QS' , '9C', '9H', '7C', '6H', '2C', '2S'],
|
||||
['4S', 'TS', '2H', '5D', 'JC', '6C ',' JH ',' QH '],
|
||||
[' JD ',' KS ',' KC ',' 4H ']
|
||||
] </pre></p>
|
||||
Tarea:
|
||||
<p> Escriba una función para tomar un número de acuerdo y tarjetas de acuerdo en el mismo orden que este algoritmo. </p>
|
||||
<p> La función debe devolver una matriz bidimensional que representa la placa FreeCell. </p>
|
||||
<p> Las ofertas también pueden <a href="http://freecellgamesolutions.com/" title="enlace: http://freecellgamesolutions.com/">compararse con las soluciones FreeCell para 1000000 juegos</a> . </p>
|
||||
<p> (Invoca una solución de video y muestra el trato inicial.) </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -73,9 +73,9 @@ tests:
|
||||
testString: 'assert(typeof dealFreeCell(1) === "object", "<code>dealFreeCell(seed)</code> should return an object.");'
|
||||
- text: <code>dealFreeCell(seed)</code> debe devolver una matriz de longitud 7.
|
||||
testString: 'assert(dealFreeCell(1).length === 7, "<code>dealFreeCell(seed)</code> should return an array of length 7.");'
|
||||
- text: ' <code>dealFreeCell(1)</code> debe devolver una matriz idéntica al ejemplo "Juego # 1"'
|
||||
- text: ' <code>dealFreeCell(1)</code> debe devolver una matriz idéntica al ejemplo "Juego # 1"'
|
||||
testString: 'assert.deepEqual(dealFreeCell(1), game1, "<code>dealFreeCell(1)</code> should return an array identical to example "Game #1"");'
|
||||
- text: ' <code>dealFreeCell(617)</code> debe devolver una matriz idéntica al ejemplo "Juego # 617"'
|
||||
- text: ' <code>dealFreeCell(617)</code> debe devolver una matriz idéntica al ejemplo "Juego # 617"'
|
||||
testString: 'assert.deepEqual(dealFreeCell(617), game617, "<code>dealFreeCell(617)</code> should return an array identical to example "Game #617"");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,19 +6,19 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Escribe una función que devuelva una copia profunda de un objeto dado. </p>
|
||||
<p> La copia no debe ser el mismo objeto que se le dio. </p>
|
||||
<p> Esta tarea no probará para: </p>
|
||||
Objetos con propiedades que son funciones
|
||||
Objetos de fecha u objeto con propiedades que son objetos de fecha
|
||||
RegEx u objeto con propiedades que son objetos de RegEx
|
||||
Copia de prototipo
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Escribe una función que devuelva una copia profunda de un objeto dado. </p>
|
||||
<p> La copia no debe ser el mismo objeto que se le dio. </p>
|
||||
<p> Esta tarea no probará para: </p>
|
||||
Objetos con propiedades que son funciones
|
||||
Objetos de fecha u objeto con propiedades que son objetos de fecha
|
||||
RegEx u objeto con propiedades que son objetos de RegEx
|
||||
Copia de prototipo
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -29,13 +29,13 @@ Copia de prototipo
|
||||
tests:
|
||||
- text: <code>deepcopy</code> debe ser una función.
|
||||
testString: 'assert(typeof deepcopy === "function", "<code>deepcopy</code> should be a function.");'
|
||||
- text: ' <code>deepcopy({test: "test"})</code> debe devolver un objeto.'
|
||||
- text: ' <code>deepcopy({test: "test"})</code> debe devolver un objeto.'
|
||||
testString: 'assert(typeof deepcopy(obj1) === "object", "<code>deepcopy({test: "test"})</code> should return an object.");'
|
||||
- text: No debe devolver el mismo objeto que se proporcionó.
|
||||
testString: 'assert(deepcopy(obj2) != obj2, "Should not return the same object that was provided.");'
|
||||
- text: 'Cuando se pasa un objeto que contiene una matriz, debe devolver una copia profunda del objeto'.
|
||||
- text: 'Cuando se pasa un objeto que contiene una matriz, debe devolver una copia profunda del objeto'
|
||||
testString: 'assert.deepEqual(deepcopy(obj2), obj2, "When passed an object containing an array, should return a deep copy of the object.");'
|
||||
- text: 'Cuando se pasa un objeto que contiene otro objeto, debe devolver una copia profunda del objeto'.
|
||||
- text: 'Cuando se pasa un objeto que contiene otro objeto, debe devolver una copia profunda del objeto'
|
||||
testString: 'assert.deepEqual(deepcopy(obj3), obj3, "When passed an object containing another object, should return a deep copy of the object.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Defina un tipo que se comporte como un entero pero que tenga un valor válido más bajo de 1 y un valor válido más alto de 10. </p>
|
||||
Errores:
|
||||
Si intenta crear una instancia de un <code>Num</code> con un valor fuera de 1 - 10
|
||||
, debe lanzar un <code>TypeError</code> con un mensaje de error de <code>'Out of range'</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>'Not a Number'</code> .
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Defina un tipo que se comporte como un entero pero que tenga un valor válido más bajo de 1 y un valor válido más alto de 10. </p>
|
||||
Errores:
|
||||
Si intenta crear una instancia de un <code>Num</code> con un valor fuera de 1 - 10
|
||||
, debe lanzar un <code>TypeError</code> con un mensaje de error de <code>'Out of range'</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>'Not a Number'</code> .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -30,15 +30,15 @@ tests:
|
||||
testString: 'assert(typeof Num === "function", "<code>Num</code> should be a function.");'
|
||||
- text: <code>new Num(4)</code> debe devolver un objeto.
|
||||
testString: 'assert(typeof (new Num(4)) === "object", "<code>new Num(4)</code> should return an object.");'
|
||||
- text: <code>new Num(\'test\')</code> debe lanzar un TypeError con el mensaje \ 'Not a Number \'.
|
||||
- text: <code>new Num(\'test\')</code> debe lanzar un TypeError con el mensaje \ 'Not a Number \'
|
||||
testString: 'assert(throws(() => new Num("test"), TypeError, "Not a Number"), "<code>new Num(\"test\")</code> should throw a TypeError with message \"Not a Number\".");'
|
||||
- text: <code>new Num(0)</code> debe lanzar un TypeError con el mensaje \ 'Fuera de rango \'.
|
||||
- text: <code>new Num(0)</code> debe lanzar un TypeError con el mensaje \ 'Fuera de rango \'
|
||||
testString: 'assert(throws(() => new Num(0), TypeError, "Out of range"), "<code>new Num(0)</code> should throw a TypeError with message \"Out of range\".");'
|
||||
- text: <code>new Num(-5)</code> debe lanzar un TypeError con el mensaje "Fuera de rango".
|
||||
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 \ 'Fuera de rango \'.
|
||||
- text: <code>new Num(10)</code> debe lanzar un TypeError con el mensaje \ 'Fuera de rango \'
|
||||
testString: 'assert(throws(() => new Num(11), TypeError, "Out of range"), "<code>new Num(10)</code> should throw a TypeError with message \"Out of range\".");'
|
||||
- text: <code>new Num(20)</code> debe lanzar un TypeError con el mensaje \ 'Fuera de rango \'.
|
||||
- text: <code>new Num(20)</code> debe lanzar un TypeError con el mensaje \ 'Fuera de rango \'
|
||||
testString: 'assert(throws(() => new Num(20), TypeError, "Out of range"), "<code>new Num(20)</code> should throw a TypeError with message \"Out of range\".");'
|
||||
- text: <code>new Num(3) + new Num(4)</code> debe ser igual a 7.
|
||||
testString: 'assert.equal(new Num(3) + new Num(4), 7, "<code>new Num(3) + new Num(4)</code> should equal 7.");'
|
||||
@@ -52,7 +52,7 @@ tests:
|
||||
testString: 'assert(new Num(3) < new Num(4), "<code>new Num(3) < new Num(4)</code> should be true.");'
|
||||
- text: <code>new Num(3) > 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 \ '5 \'
|
||||
- text: <code>(new Num(5)).toString()</code> debe devolver \ '5 \'
|
||||
testString: 'assert.equal((new Num(5)).toString(), "5", "<code>(new Num(5)).toString()</code> should return \"5\"");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,32 +6,32 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Hay una ciudad altamente organizada que ha decidido asignar un número a cada uno de sus departamentos: </p>
|
||||
Policía del departamento
|
||||
Saneamiento departamento de
|
||||
Cuerpo de bomberos
|
||||
<p> Cada departamento puede tener un número entre 1 y 7 (inclusive). </p><p> Los tres números de departamento deben ser únicos (diferentes entre sí) y deben sumar hasta el número 12. </p><p> Al jefe de la policía no le gustan los números impares y quiere tener un número par para su departamento. </p>
|
||||
Tarea:
|
||||
<p> Escriba un programa que produzca todas las combinaciones válidas: </p>
|
||||
<p> [2, 3, 7] </p>
|
||||
<p> [2, 4, 6] </p>
|
||||
<p> [2, 6, 4] </p>
|
||||
<p> [2, 7, 3] </p>
|
||||
<p> [4, 1, 7] </p>
|
||||
<p> [4, 2, 6] </p>
|
||||
<p> [4, 3, 5] </p>
|
||||
<p> [4, 5, 3] </p>
|
||||
<p> [4, 6, 2] </p>
|
||||
<p> [4, 7, 1] </p>
|
||||
<p> [6, 1, 5] </p>
|
||||
<p> [6, 2, 4] </p>
|
||||
<p> [6, 4, 2] </p>
|
||||
<p> [6, 5, 1] </p>
|
||||
<section id='description'>
|
||||
<p> Hay una ciudad altamente organizada que ha decidido asignar un número a cada uno de sus departamentos: </p>
|
||||
Policía del departamento
|
||||
Saneamiento departamento de
|
||||
Cuerpo de bomberos
|
||||
<p> Cada departamento puede tener un número entre 1 y 7 (inclusive). </p><p> Los tres números de departamento deben ser únicos (diferentes entre sí) y deben sumar hasta el número 12. </p><p> Al jefe de la policía no le gustan los números impares y quiere tener un número par para su departamento. </p>
|
||||
Tarea:
|
||||
<p> Escriba un programa que produzca todas las combinaciones válidas: </p>
|
||||
<p> [2, 3, 7] </p>
|
||||
<p> [2, 4, 6] </p>
|
||||
<p> [2, 6, 4] </p>
|
||||
<p> [2, 7, 3] </p>
|
||||
<p> [4, 1, 7] </p>
|
||||
<p> [4, 2, 6] </p>
|
||||
<p> [4, 3, 5] </p>
|
||||
<p> [4, 5, 3] </p>
|
||||
<p> [4, 6, 2] </p>
|
||||
<p> [4, 7, 1] </p>
|
||||
<p> [6, 1, 5] </p>
|
||||
<p> [6, 2, 4] </p>
|
||||
<p> [6, 4, 2] </p>
|
||||
<p> [6, 5, 1] </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -42,11 +42,11 @@ Tarea:
|
||||
tests:
|
||||
- text: <code>combinations</code> deben ser una función.
|
||||
testString: 'assert(typeof combinations === "function", "<code>combinations</code> should be a function.");'
|
||||
- text: ' <code>combinations([1, 2, 3], 6)</code> deben devolver un Array.'
|
||||
- text: ' <code>combinations([1, 2, 3], 6)</code> deben devolver un Array.'
|
||||
testString: 'assert(Array.isArray(combinations([1, 2, 3], 6)), "<code>combinations([1, 2, 3], 6)</code> should return an Array.");'
|
||||
- text: ' <code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> deben devolver una matriz de longitud 14.'
|
||||
- text: ' <code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> deben devolver una matriz de longitud 14.'
|
||||
testString: 'assert(combinations(nums, total).length === len, "<code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> should return an array of length 14.");'
|
||||
- text: ' <code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> deben devolver todas las combinaciones válidas.'
|
||||
- text: ' <code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> deben devolver todas las combinaciones válidas.'
|
||||
testString: 'assert.deepEqual(combinations(nums, total), result, "<code>combinations([1, 2, 3, 4, 5, 6, 7], 12)</code> should return all valid combinations.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,13 +6,13 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Convierte una fecha dada del <a href="https://en.wikipedia.org/wiki/Gregorian calendar" title="wp: calendario gregoriano">calendario gregoriano al calendario</a> <a href="https://en.wikipedia.org/wiki/Discordian calendar" title="wp: calendario discordiano">Discordiano</a> . </p>
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Convierte una fecha dada del <a href="https://en.wikipedia.org/wiki/Gregorian calendar" title="wp: calendario gregoriano">calendario gregoriano al calendario</a> <a href="https://en.wikipedia.org/wiki/Discordian calendar" title="wp: calendario discordiano">Discordiano</a> . </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -23,19 +23,19 @@ Tarea:
|
||||
tests:
|
||||
- text: <code>discordianDate</code> es una función.
|
||||
testString: 'assert(typeof discordianDate === "function", "<code>discordianDate</code> is a function.");'
|
||||
- text: ' <code>discordianDate(new Date(2010, 6, 22))</code> debe devolver <code>"Pungenday, the 57th day of Confusion in the YOLD 3176"</code> .'
|
||||
- text: ' <code>discordianDate(new Date(2010, 6, 22))</code> debe devolver <code>"Pungenday, the 57th day of Confusion in the YOLD 3176"</code> .'
|
||||
testString: 'assert(discordianDate(new Date(2010, 6, 22)) === "Pungenday, the 57th day of Confusion in the YOLD 3176", "<code>discordianDate(new Date(2010, 6, 22))</code> should return <code>"Pungenday, the 57th day of Confusion in the YOLD 3176"</code>.");'
|
||||
- text: ' <code>discordianDate(new Date(2012, 1, 28))</code> debe devolver <code>"Prickle-Prickle, the 59th day of Chaos in the YOLD 3178"</code> .'
|
||||
- text: ' <code>discordianDate(new Date(2012, 1, 28))</code> debe devolver <code>"Prickle-Prickle, the 59th day of Chaos in the YOLD 3178"</code> .'
|
||||
testString: 'assert(discordianDate(new Date(2012, 1, 28)) === "Prickle-Prickle, the 59th day of Chaos in the YOLD 3178", "<code>discordianDate(new Date(2012, 1, 28))</code> should return <code>"Prickle-Prickle, the 59th day of Chaos in the YOLD 3178"</code>.");'
|
||||
- text: ' <code>discordianDate(new Date(2012, 1, 29))</code> debe devolver <code>"Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\"s Day!"</code> .'
|
||||
- text: ' <code>discordianDate(new Date(2012, 1, 29))</code> debe devolver <code>"Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\"s Day!"</code> .'
|
||||
testString: 'assert(discordianDate(new Date(2012, 1, 29)) === "Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\"s Day!", "<code>discordianDate(new Date(2012, 1, 29))</code> should return <code>"Setting Orange, the 60th day of Chaos in the YOLD 3178. Celebrate St. Tib\"s Day!"</code>.");'
|
||||
- text: ' <code>discordianDate(new Date(2012, 2, 1))</code> debe devolver <code>"Setting Orange, the 60th day of Chaos in the YOLD 3178"</code> .'
|
||||
- text: ' <code>discordianDate(new Date(2012, 2, 1))</code> debe devolver <code>"Setting Orange, the 60th day of Chaos in the YOLD 3178"</code> .'
|
||||
testString: 'assert(discordianDate(new Date(2012, 2, 1)) === "Setting Orange, the 60th day of Chaos in the YOLD 3178", "<code>discordianDate(new Date(2012, 2, 1))</code> should return <code>"Setting Orange, the 60th day of Chaos in the YOLD 3178"</code>.");'
|
||||
- text: ' <code>discordianDate(new Date(2010, 0, 5))</code> debe devolver <code>"Setting Orange, the 5th day of Chaos in the YOLD 3176. Celebrate Mungday!"</code> .
|
||||
- text: ' <code>discordianDate(new Date(2010, 0, 5))</code> debe devolver <code>"Setting Orange, the 5th day of Chaos in the YOLD 3176. Celebrate Mungday!"</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: ' <code>discordianDate(new Date(2011, 4, 3))</code> debe devolver <code>"Pungenday, the 50th day of Discord in the YOLD 3177. Celebrate Discoflux!"</code> .
|
||||
- text: ' <code>discordianDate(new Date(2011, 4, 3))</code> debe devolver <code>"Pungenday, the 50th day of Discord in the YOLD 3177. Celebrate Discoflux!"</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: ' <code>discordianDate(new Date(2015, 9, 19))</code> debe devolver <code>"Boomtime, the 73rd day of Bureaucracy in the YOLD 3181"</code> .
|
||||
- text: ' <code>discordianDate(new Date(2015, 9, 19))</code> debe devolver <code>"Boomtime, the 73rd day of Bureaucracy in the YOLD 3181"</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>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Implementar operaciones básicas de matriz de matriz de elementos y matriz escalar. </p><p> Implementar: </p>
|
||||
<p> :: * Además </p>
|
||||
<p> :: * resta </p>
|
||||
<p> :: * multiplicación </p>
|
||||
<p> :: * división </p>
|
||||
<p> :: * exponenciación </p>
|
||||
<p> El primer parámetro será la operación a realizar, por ejemplo: "m_add" para la adición de matriz y "s_add" para la adición escalar. Los parámetros segundo y tercero serán las matrices sobre las que se realizarán las operaciones.
|
||||
<section id='description'>
|
||||
<p> Implementar operaciones básicas de matriz de matriz de elementos y matriz escalar. </p><p> Implementar: </p>
|
||||
<p> :: * Además </p>
|
||||
<p> :: * resta </p>
|
||||
<p> :: * multiplicación </p>
|
||||
<p> :: * división </p>
|
||||
<p> :: * exponenciación </p>
|
||||
<p> El primer parámetro será la operación a realizar, por ejemplo: "m_add" para la adición de matriz y "s_add" para la adición escalar. Los parámetros segundo y tercero serán las matrices sobre las que se realizarán las operaciones.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -28,19 +28,19 @@ challengeType: 5
|
||||
tests:
|
||||
- text: <code>operation</code> es una función.
|
||||
testString: 'assert(typeof operation === "function", "<code>operation</code> is a function.");'
|
||||
- text: ' <code>operation("m_add",[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[2,4],[6,8]]</code> .
|
||||
- text: ' <code>operation("m_add",[[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: ' <code>operation("s_add",[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[3,4],[5,6]]</code> .
|
||||
- text: ' <code>operation("s_add",[[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: ' <code>operation("m_sub",[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[0,0],[0,0]]</code> .
|
||||
- text: ' <code>operation("m_sub",[[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: ' <code>operation("m_mult",[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[1,4],[9,16]]</code> .
|
||||
- text: ' <code>operation("m_mult",[[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: ' <code>operation("m_div",[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[1,1],[1,1]]</code> .
|
||||
- text: ' <code>operation("m_div",[[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: 'la <code>operation("m_exp",[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[1,4],[27,256]]</code> .'
|
||||
- text: 'la <code>operation("m_exp",[[1,2],[3,4]],[[1,2],[3,4]])</code> debe devolver <code>[[1,4],[27,256]]</code> .'
|
||||
testString: 'assert.deepEqual(operation("m_exp", [[1, 2], [3, 4]], [[1, 2], [3, 4]]), [[1, 4], [27, 256]], "<code>operation("m_exp",[[1,2],[3,4]],[[1,2],[3,4]])</code> should return <code>[[1,4],[27,256]]</code>.");'
|
||||
- text: ' <code>operation("m_add",[[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> . '
|
||||
- text: ' <code>operation("m_add",[[1,2,3,4],[5,6,7,8]],[[9,10,11,12],[13,14,15,16]])</code> debe devolver <code>[[10,12,14,16],[18,20,22,24]]</code> . '
|
||||
testString: 'assert.deepEqual(operation("m_add", [[1, 2, 3, 4], [5, 6, 7, 8]], [[9, 10, 11, 12], [13, 14, 15, 16]]), [[10, 12, 14, 16], [18, 20, 22, 24]], "<code>operation("m_add",[[1,2,3,4],[5,6,7,8]],[[9,10,11,12],[13,14,15,16]])</code> should return <code>[[10,12,14,16],[18,20,22,24]]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,13 +6,13 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Un emirp (primo deletreado al revés) son primos que cuando se invierten (en su representación decimal) son primos diferentes. </p>
|
||||
<p> Escriba una función que debería ser capaz de: Mostrar los primeros <b>n</b> eprimes números. Mostrar los números de eprimes en un rango. Mostrar el número de eprimes en un rango. Mostrar el <b>n <sup>número de</sup></b> eprimes. <p> La función debe tener dos parámetros. El primero recibirá <b>n</b> o el rango como una matriz. El segundo recibirá un valor booleano, que especifica si la función devuelve los eprimes como una matriz o un único número (el número de números primos en el rango o la <b><sup>enésima</sup></b> primo). De acuerdo con los parámetros, la función debe devolver una matriz o un número.
|
||||
<section id='description'>
|
||||
<p> Un emirp (primo deletreado al revés) son primos que cuando se invierten (en su representación decimal) son primos diferentes. </p>
|
||||
<p> Escriba una función que debería ser capaz de: Mostrar los primeros <b>n</b> eprimes números. Mostrar los números de eprimes en un rango. Mostrar el número de eprimes en un rango. Mostrar el <b>n <sup>número de</sup></b> eprimes. <p> La función debe tener dos parámetros. El primero recibirá <b>n</b> o el rango como una matriz. El segundo recibirá un valor booleano, que especifica si la función devuelve los eprimes como una matriz o un único número (el número de números primos en el rango o la <b><sup>enésima</sup></b> primo). De acuerdo con los parámetros, la función debe devolver una matriz o un número.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -23,13 +23,13 @@ challengeType: 5
|
||||
tests:
|
||||
- text: <code>emirps</code> es una función.
|
||||
testString: 'assert(typeof emirps === "function", "<code>emirps</code> is a function.");'
|
||||
- text: ' <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> '
|
||||
- text: ' <code>emirps(20,true)</code> debe devolver <code>[13,17,31,37,71,73,79,97,107,113,149,157,167,179,199,311,337,347,359,389]</code> '
|
||||
testString: 'assert.deepEqual(emirps(20, true), [13, 17, 31, 37, 71, 73, 79, 97, 107, 113, 149, 157, 167, 179, 199, 311, 337, 347, 359, 389], "<code>emirps(20,true)</code> should return <code>[13,17,31,37,71,73,79,97,107,113,149,157,167,179,199,311,337,347,359,389]</code>");'
|
||||
- text: <code>emirps(10000)</code> deben devolver <code>948349</code>
|
||||
testString: 'assert.deepEqual(emirps(10000), 948349, "<code>emirps(10000)</code> should return <code>948349</code>");'
|
||||
- text: ' <code>emirps([7700,8000],true)</code> debe devolver <code>[7717,7757,7817,7841,7867,7879,7901,7927,7949,7951,7963]</code> '
|
||||
- text: ' <code>emirps([7700,8000],true)</code> debe devolver <code>[7717,7757,7817,7841,7867,7879,7901,7927,7949,7951,7963]</code> '
|
||||
testString: 'assert.deepEqual(emirps([7700, 8000], true), [7717, 7757, 7817, 7841, 7867, 7879, 7901, 7927, 7949, 7951, 7963], "<code>emirps([7700,8000],true)</code> should return <code>[7717,7757,7817,7841,7867,7879,7901,7927,7949,7951,7963]</code>");'
|
||||
- text: ' <code>emirps([7700,8000],true)</code> debe devolver <code>11</code> '
|
||||
- text: ' <code>emirps([7700,8000],true)</code> debe devolver <code>11</code> '
|
||||
testString: 'assert.deepEqual(emirps([7700, 8000], false), 11, "<code>emirps([7700,8000],true)</code> should return <code>11</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,20 +6,20 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Un índice de equilibrio de una secuencia es un índice en la secuencia tal que la suma de los elementos en los índices más bajos es igual a la suma de los elementos en los índices más altos. </p>
|
||||
<p> Por ejemplo, en una secuencia <big>$ A $</big> : </p><p> <big>:::: $ A_0 = -7 $</big> </p>
|
||||
<p> :::: <big>$ A_1 = 1 $</big> </p>
|
||||
<p> <big>:::: $ A_2 = 5 $</big> </p>
|
||||
<p> <big>:::: $ A_3 = 2 $</big> </p>
|
||||
<p> <big>:::: $ A_4 = -4 $</big> </p>
|
||||
<p> <big>:::: $ A_5 = 3 $</big> </p>
|
||||
<p> <big>:::: $ A_6 = 0 $</big> </p><p> 3 es un índice de equilibrio, porque: </p><p> <big>:::: $ A_0 + A_1 + A_2 = A_4 + A_5 + A_6 $</big> </p><p> 6 también es un índice de equilibrio, porque: </p><p> <big>:::: $ A_0 + A_1 + A_2 + A_3 + A_4 + A_5 = 0 $</big> </p><p> (la suma de cero elementos es cero) </p><p> 7 no es un índice de equilibrio, porque no es un índice válido de secuencia <big>$ A $</big> . </p>
|
||||
<p> Escriba una función que, dada una secuencia, devuelva sus índices de equilibrio (si los hay). </p><p> Supongamos que la secuencia puede ser muy larga. </p>
|
||||
<section id='description'>
|
||||
<p> Un índice de equilibrio de una secuencia es un índice en la secuencia tal que la suma de los elementos en los índices más bajos es igual a la suma de los elementos en los índices más altos. </p>
|
||||
<p> Por ejemplo, en una secuencia <big>$ A $</big> : </p><p> <big>:::: $ A_0 = -7 $</big> </p>
|
||||
<p> :::: <big>$ A_1 = 1 $</big> </p>
|
||||
<p> <big>:::: $ A_2 = 5 $</big> </p>
|
||||
<p> <big>:::: $ A_3 = 2 $</big> </p>
|
||||
<p> <big>:::: $ A_4 = -4 $</big> </p>
|
||||
<p> <big>:::: $ A_5 = 3 $</big> </p>
|
||||
<p> <big>:::: $ A_6 = 0 $</big> </p><p> 3 es un índice de equilibrio, porque: </p><p> <big>:::: $ A_0 + A_1 + A_2 = A_4 + A_5 + A_6 $</big> </p><p> 6 también es un índice de equilibrio, porque: </p><p> <big>:::: $ A_0 + A_1 + A_2 + A_3 + A_4 + A_5 = 0 $</big> </p><p> (la suma de cero elementos es cero) </p><p> 7 no es un índice de equilibrio, porque no es un índice válido de secuencia <big>$ A $</big> . </p>
|
||||
<p> Escriba una función que, dada una secuencia, devuelva sus índices de equilibrio (si los hay). </p><p> Supongamos que la secuencia puede ser muy larga. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -30,17 +30,17 @@ challengeType: 5
|
||||
tests:
|
||||
- text: <code>equilibrium</code> es una función.
|
||||
testString: 'assert(typeof equilibrium === "function", "<code>equilibrium</code> is a function.");'
|
||||
- text: 'el <code>equilibrium([-7, 1, 5, 2, -4, 3, 0])</code> debe devolver <code>[3,6]</code> .'
|
||||
- text: 'el <code>equilibrium([-7, 1, 5, 2, -4, 3, 0])</code> debe devolver <code>[3,6]</code> .'
|
||||
testString: 'assert.deepEqual(equilibrium(tests[0]), ans[0], "<code>equilibrium([-7, 1, 5, 2, -4, 3, 0])</code> should return <code>[3,6]</code>.");'
|
||||
- text: 'el <code>equilibrium([2, 4, 6])</code> debe devolver <code>[]</code> .'
|
||||
- text: 'el <code>equilibrium([2, 4, 6])</code> debe devolver <code>[]</code> .'
|
||||
testString: 'assert.deepEqual(equilibrium(tests[1]), ans[1], "<code>equilibrium([2, 4, 6])</code> should return <code>[]</code>.");'
|
||||
- text: 'el <code>equilibrium([2, 9, 2])</code> debe devolver <code>[1]</code> .'
|
||||
- text: 'el <code>equilibrium([2, 9, 2])</code> debe devolver <code>[1]</code> .'
|
||||
testString: 'assert.deepEqual(equilibrium(tests[2]), ans[2], "<code>equilibrium([2, 9, 2])</code> should return <code>[1]</code>.");'
|
||||
- text: 'el <code>equilibrium([1, -1, 1, -1, 1, -1, 1])</code> debe devolver <code>[0,1,2,3,4,5,6]</code> .'
|
||||
- text: 'el <code>equilibrium([1, -1, 1, -1, 1, -1, 1])</code> debe devolver <code>[0,1,2,3,4,5,6]</code> .'
|
||||
testString: 'assert.deepEqual(equilibrium(tests[3]), ans[3], "<code>equilibrium([1, -1, 1, -1, 1, -1, 1])</code> should return <code>[0,1,2,3,4,5,6]</code>.");'
|
||||
- text: 'el <code>equilibrium([1])</code> debe devolver <code>[0]</code> .'
|
||||
- text: 'el <code>equilibrium([1])</code> debe devolver <code>[0]</code> .'
|
||||
testString: 'assert.deepEqual(equilibrium(tests[4]), ans[4], "<code>equilibrium([1])</code> should return <code>[0]</code>.");'
|
||||
- text: 'el <code>equilibrium([])</code> debe devolver <code>[]</code> .'
|
||||
- text: 'el <code>equilibrium([])</code> debe devolver <code>[]</code> .'
|
||||
testString: 'assert.deepEqual(equilibrium(tests[5]), ans[5], "<code>equilibrium([])</code> should return <code>[]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,53 +6,53 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> La multiplicación etíope es un método para multiplicar enteros utilizando solo la suma, el doblado y la reducción a la mitad. </p>
|
||||
<p> Método: </p>
|
||||
Toma dos números para multiplicarlos y escríbelos en la parte superior de las dos columnas.
|
||||
En la columna de la izquierda, reduzca a la mitad el último número, descartando cualquier resto, y escriba el resultado debajo del último en la misma columna, hasta que escriba un valor de 1.
|
||||
En la columna de la derecha, doble el número de la última vez y Escribe el resultado a continuación. deténgase cuando agregue un resultado en la misma fila donde la columna de la izquierda muestra 1.
|
||||
Examine la tabla producida y descarte cualquier fila donde el valor en la columna de la izquierda sea par.
|
||||
Suma los valores en la columna de la derecha que quedan para producir el resultado de multiplicar los dos números originales juntos
|
||||
<p> Por ejemplo: 17 × 34. </p>
|
||||
<p> 17 34 </p>
|
||||
<p> Reduciendo a la mitad la primera columna: </p>
|
||||
<p> 17 34 </p>
|
||||
<p> 8 </p>
|
||||
<p> 4 </p>
|
||||
<p> 2 </p>
|
||||
<p> 1 </p>
|
||||
<p> Duplicando la segunda columna: </p>
|
||||
<p> 17 34 </p>
|
||||
<p> 8 68 </p>
|
||||
<p> 4 136 </p>
|
||||
<p> 2 272 </p>
|
||||
<p> 1 544 </p>
|
||||
<p> Filas tachadas cuya primera celda es par: </p>
|
||||
<p> 17 34 </p>
|
||||
<p> 8 <strike>68</strike> </p>
|
||||
<p> 4 <strike>136</strike> </p>
|
||||
<p> 2 <strike>272</strike> </p>
|
||||
<p> 1 544 </p>
|
||||
<p> Suma los números restantes en la columna de la derecha: </p>
|
||||
<p> 17 34 </p>
|
||||
<p> 8 - </p>
|
||||
<p> 4 --- </p>
|
||||
<p> 2 --- </p>
|
||||
<p> 1 544 </p>
|
||||
<p> ==== </p>
|
||||
<p> 578 </p>
|
||||
<p> Entonces 17 multiplicado por 34, por el método etíope es 578. </p>
|
||||
Tarea:
|
||||
<p> La tarea es definir tres funciones nombradas / métodos / procedimientos / subrutinas: </p>
|
||||
uno para reducir a la mitad un número entero,
|
||||
uno para duplicar un número entero y
|
||||
uno para indicar si un número entero es par.
|
||||
<p> Usa estas funciones para crear una función que haga la multiplicación etíope. </p>
|
||||
<section id='description'>
|
||||
<p> La multiplicación etíope es un método para multiplicar enteros utilizando solo la suma, el doblado y la reducción a la mitad. </p>
|
||||
<p> Método: </p>
|
||||
Toma dos números para multiplicarlos y escríbelos en la parte superior de las dos columnas.
|
||||
En la columna de la izquierda, reduzca a la mitad el último número, descartando cualquier resto, y escriba el resultado debajo del último en la misma columna, hasta que escriba un valor de 1.
|
||||
En la columna de la derecha, doble el número de la última vez y Escribe el resultado a continuación. deténgase cuando agregue un resultado en la misma fila donde la columna de la izquierda muestra 1.
|
||||
Examine la tabla producida y descarte cualquier fila donde el valor en la columna de la izquierda sea par.
|
||||
Suma los valores en la columna de la derecha que quedan para producir el resultado de multiplicar los dos números originales juntos
|
||||
<p> Por ejemplo: 17 × 34. </p>
|
||||
<p> 17 34 </p>
|
||||
<p> Reduciendo a la mitad la primera columna: </p>
|
||||
<p> 17 34 </p>
|
||||
<p> 8 </p>
|
||||
<p> 4 </p>
|
||||
<p> 2 </p>
|
||||
<p> 1 </p>
|
||||
<p> Duplicando la segunda columna: </p>
|
||||
<p> 17 34 </p>
|
||||
<p> 8 68 </p>
|
||||
<p> 4 136 </p>
|
||||
<p> 2 272 </p>
|
||||
<p> 1 544 </p>
|
||||
<p> Filas tachadas cuya primera celda es par: </p>
|
||||
<p> 17 34 </p>
|
||||
<p> 8 <strike>68</strike> </p>
|
||||
<p> 4 <strike>136</strike> </p>
|
||||
<p> 2 <strike>272</strike> </p>
|
||||
<p> 1 544 </p>
|
||||
<p> Suma los números restantes en la columna de la derecha: </p>
|
||||
<p> 17 34 </p>
|
||||
<p> 8 - </p>
|
||||
<p> 4 --- </p>
|
||||
<p> 2 --- </p>
|
||||
<p> 1 544 </p>
|
||||
<p> ==== </p>
|
||||
<p> 578 </p>
|
||||
<p> Entonces 17 multiplicado por 34, por el método etíope es 578. </p>
|
||||
Tarea:
|
||||
<p> La tarea es definir tres funciones nombradas / métodos / procedimientos / subrutinas: </p>
|
||||
uno para reducir a la mitad un número entero,
|
||||
uno para duplicar un número entero y
|
||||
uno para indicar si un número entero es par.
|
||||
<p> Usa estas funciones para crear una función que haga la multiplicación etíope. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -63,15 +63,15 @@ uno para indicar si un número entero es par.
|
||||
tests:
|
||||
- text: <code>eth_mult</code> es una función.
|
||||
testString: 'assert(typeof eth_mult === "function", "<code>eth_mult</code> is a function.");'
|
||||
- text: ' <code>eth_mult(17,34)</code> debe devolver <code>578</code> '.
|
||||
- text: ' <code>eth_mult(17,34)</code> debe devolver <code>578</code> '
|
||||
testString: 'assert.equal(eth_mult(17, 34), 578, "<code>eth_mult(17,34)</code> should return <code>578</code>.");'
|
||||
- text: ' <code>eth_mult(23,46)</code> debe devolver <code>1058</code> '.
|
||||
- text: ' <code>eth_mult(23,46)</code> debe devolver <code>1058</code> '
|
||||
testString: 'assert.equal(eth_mult(23, 46), 1058, "<code>eth_mult(23,46)</code> should return <code>1058</code>.");'
|
||||
- text: ' <code>eth_mult(12,27)</code> debe devolver <code>324</code> '
|
||||
- text: ' <code>eth_mult(12,27)</code> debe devolver <code>324</code> '
|
||||
testString: 'assert.equal(eth_mult(12, 27), 324, "<code>eth_mult(12,27)</code> should return <code>324</code>.");'
|
||||
- text: ' <code>eth_mult(56,98)</code> debe devolver <code>5488</code> '.
|
||||
- text: ' <code>eth_mult(56,98)</code> debe devolver <code>5488</code> '
|
||||
testString: 'assert.equal(eth_mult(56, 98), 5488, "<code>eth_mult(56,98)</code> should return <code>5488</code>.");'
|
||||
- text: ' <code>eth_mult(63,74)</code> debe devolver <code>4662</code> '.
|
||||
- text: ' <code>eth_mult(63,74)</code> debe devolver <code>4662</code> '
|
||||
testString: 'assert.equal(eth_mult(63, 74), 4662, "<code>eth_mult(63,74)</code> should return <code>4662</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,28 +6,28 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> El método de Euler aproxima numéricamente las soluciones de ecuaciones diferenciales ordinarias de primer orden (EDO) con un valor inicial dado. Es un método explícito para resolver problemas de valor inicial (IVP), como se describe en <a href="https://en.wikipedia.org/wiki/Euler method" title="wp: método de euler">la página de wikipedia</a> . </p><p> La EDO debe ser proporcionada en la siguiente forma: </p><p> :: <big>$ \ frac {dy (t)} {dt} = f (t, y (t)) $</big> </p><p> con un valor inicial </p><p> :: <big>$ y (t_0) = y_0 $</big> </p><p> Para obtener una solución numérica, reemplazamos el derivado en LHS con una aproximación de diferencias finitas: </p><p> :: <big>$ \ frac {dy (t)} {dt} \ approx \ frac {y (t + h) -y (t)} {h} $</big> </p><p> luego resuelva por $ y (t + h) $: </p><p> :: <big>$ y (t + h) \ approx y (t) + h \, \ frac {dy (t)} {dt} $</big> </p><p> que es lo mismo que </p><p> :: <big>$ y (t + h) \ approx y (t) + h \, f (t, y (t)) $</big> </p><p> La regla de solución iterativa es entonces: </p><p> :: <big>$ y_ {n + 1} = y_n + h \, f (t_n, y_n) $</big> </p><p> donde <big>$ h $</big> es el tamaño del paso, el parámetro más relevante para la precisión de la solución. Un tamaño de paso más pequeño aumenta la precisión, pero también el costo de cómputo, por lo que siempre tiene que ser seleccionado de acuerdo con el problema en cuestión. </p>
|
||||
<p> Ejemplo: Ley de enfriamiento de Newton </p><p> La ley de enfriamiento de Newton describe cómo un objeto de temperatura inicial <big>$ T (t_0) = T_0 $ se</big> enfría en un entorno de temperatura <big>$ T_R $</big> : </p><p> :: <big>$ \ frac {dT (t)} {dt} = -k \, \ Delta T $</big> </p>
|
||||
<p> o </p>
|
||||
<p> :: <big>$ \ frac {dT (t)} {dt} = -k \, (T (t) - T_R) $</big> </p>
|
||||
<p> Dice que la tasa de enfriamiento <big>$ \ frac {dT (t)} {dt} $</big> del objeto es proporcional a la diferencia de temperatura actual <big>$ \ Delta T = (T (t) - T_R) $</big> al entorno circundante. </p><p> La solución analítica, que compararemos con la aproximación numérica, es </p>
|
||||
<p> :: <big>$ T (t) = T_R + (T_0 - T_R) \; e ^ {- kt} $</big> </p>
|
||||
Tarea:
|
||||
<p> Implemente una rutina del método de Euler y luego úselo para resolver el ejemplo dado de la ley de enfriamiento de Newton para tres tamaños de pasos diferentes de: </p>
|
||||
<p> :: * 2 s </p>
|
||||
<p> :: * 5 sy </p>
|
||||
<p> :: * 10 s </p>
|
||||
<p> y comparar con la solución analítica. </p>
|
||||
Valores iniciales:
|
||||
<p> :: * temperatura inicial <big>$ T_0 $</big> será de 100 ° C </p>
|
||||
<p> :: * temperatura ambiente <big>$ T_R $</big> será 20 ° C </p>
|
||||
<p> :: * constante de refrigeración <big>$ k $</big> será 0.07 </p>
|
||||
<p> :: * El intervalo de tiempo para calcular será de 0 s ──► 100 s </p>
|
||||
<section id='description'>
|
||||
<p> El método de Euler aproxima numéricamente las soluciones de ecuaciones diferenciales ordinarias de primer orden (EDO) con un valor inicial dado. Es un método explícito para resolver problemas de valor inicial (IVP), como se describe en <a href="https://en.wikipedia.org/wiki/Euler method" title="wp: método de euler">la página de wikipedia</a> . </p><p> La EDO debe ser proporcionada en la siguiente forma: </p><p> :: <big>$ \ frac {dy (t)} {dt} = f (t, y (t)) $</big> </p><p> con un valor inicial </p><p> :: <big>$ y (t_0) = y_0 $</big> </p><p> Para obtener una solución numérica, reemplazamos el derivado en LHS con una aproximación de diferencias finitas: </p><p> :: <big>$ \ frac {dy (t)} {dt} \ approx \ frac {y (t + h) -y (t)} {h} $</big> </p><p> luego resuelva por $ y (t + h) $: </p><p> :: <big>$ y (t + h) \ approx y (t) + h \, \ frac {dy (t)} {dt} $</big> </p><p> que es lo mismo que </p><p> :: <big>$ y (t + h) \ approx y (t) + h \, f (t, y (t)) $</big> </p><p> La regla de solución iterativa es entonces: </p><p> :: <big>$ y_ {n + 1} = y_n + h \, f (t_n, y_n) $</big> </p><p> donde <big>$ h $</big> es el tamaño del paso, el parámetro más relevante para la precisión de la solución. Un tamaño de paso más pequeño aumenta la precisión, pero también el costo de cómputo, por lo que siempre tiene que ser seleccionado de acuerdo con el problema en cuestión. </p>
|
||||
<p> Ejemplo: Ley de enfriamiento de Newton </p><p> La ley de enfriamiento de Newton describe cómo un objeto de temperatura inicial <big>$ T (t_0) = T_0 $ se</big> enfría en un entorno de temperatura <big>$ T_R $</big> : </p><p> :: <big>$ \ frac {dT (t)} {dt} = -k \, \ Delta T $</big> </p>
|
||||
<p> o </p>
|
||||
<p> :: <big>$ \ frac {dT (t)} {dt} = -k \, (T (t) - T_R) $</big> </p>
|
||||
<p> Dice que la tasa de enfriamiento <big>$ \ frac {dT (t)} {dt} $</big> del objeto es proporcional a la diferencia de temperatura actual <big>$ \ Delta T = (T (t) - T_R) $</big> al entorno circundante. </p><p> La solución analítica, que compararemos con la aproximación numérica, es </p>
|
||||
<p> :: <big>$ T (t) = T_R + (T_0 - T_R) \; e ^ {- kt} $</big> </p>
|
||||
Tarea:
|
||||
<p> Implemente una rutina del método de Euler y luego úselo para resolver el ejemplo dado de la ley de enfriamiento de Newton para tres tamaños de pasos diferentes de: </p>
|
||||
<p> :: * 2 s </p>
|
||||
<p> :: * 5 sy </p>
|
||||
<p> :: * 10 s </p>
|
||||
<p> y comparar con la solución analítica. </p>
|
||||
Valores iniciales:
|
||||
<p> :: * temperatura inicial <big>$ T_0 $</big> será de 100 ° C </p>
|
||||
<p> :: * temperatura ambiente <big>$ T_R $</big> será 20 ° C </p>
|
||||
<p> :: * constante de refrigeración <big>$ k $</big> será 0.07 </p>
|
||||
<p> :: * El intervalo de tiempo para calcular será de 0 s ──► 100 s </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -38,13 +38,13 @@ Valores iniciales:
|
||||
tests:
|
||||
- text: <code>eulersMethod</code> es una función.
|
||||
testString: 'assert(typeof eulersMethod === "function", "<code>eulersMethod</code> is a function.");'
|
||||
- text: ' <code>eulersMethod(0, 100, 100, 10)</code> debe devolver un número'.
|
||||
- text: ' <code>eulersMethod(0, 100, 100, 10)</code> debe devolver un número'
|
||||
testString: 'assert(typeof eulersMethod(0, 100, 100, 10) === "number", "<code>eulersMethod(0, 100, 100, 10)</code> should return a number.");'
|
||||
- text: ' <code>eulersMethod(0, 100, 100, 10)</code> debe devolver 20.0424631833732.'
|
||||
- text: ' <code>eulersMethod(0, 100, 100, 10)</code> debe devolver 20.0424631833732.'
|
||||
testString: 'assert.equal(eulersMethod(0, 100, 100, 2), 20.0424631833732, "<code>eulersMethod(0, 100, 100, 10)</code> should return 20.0424631833732.");'
|
||||
- text: ' <code>eulersMethod(0, 100, 100, 10)</code> debe devolver 20.01449963666907.'
|
||||
- text: ' <code>eulersMethod(0, 100, 100, 10)</code> debe devolver 20.01449963666907.'
|
||||
testString: 'assert.equal(eulersMethod(0, 100, 100, 5), 20.01449963666907, "<code>eulersMethod(0, 100, 100, 10)</code> should return 20.01449963666907.");'
|
||||
- text: ' <code>eulersMethod(0, 100, 100, 10)</code> debe devolver 20.000472392.'
|
||||
- text: ' <code>eulersMethod(0, 100, 100, 10)</code> debe devolver 20.000472392.'
|
||||
testString: 'assert.equal(eulersMethod(0, 100, 100, 10), 20.000472392, "<code>eulersMethod(0, 100, 100, 10)</code> should return 20.000472392.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,13 +6,13 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Escribe una función para calcular el coeficiente binomial para el valor dado de n y k. </p><p> Se recomienda esta fórmula: </p>
|
||||
$ \ binom {n} {k} = \ frac {n!} {(Nk)! K!} = \ Frac {n (n-1) (n-2) \ ldots (n-k + 1)} {k (k-1) (k-2) \ ldots 1} $
|
||||
<section id='description'>
|
||||
<p> Escribe una función para calcular el coeficiente binomial para el valor dado de n y k. </p><p> Se recomienda esta fórmula: </p>
|
||||
$ \ binom {n} {k} = \ frac {n!} {(Nk)! K!} = \ Frac {n (n-1) (n-2) \ ldots (n-k + 1)} {k (k-1) (k-2) \ ldots 1} $
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -23,15 +23,15 @@ $ \ binom {n} {k} = \ frac {n!} {(Nk)! K!} = \ Frac {n (n-1) (n-2) \ ldots (n-k
|
||||
tests:
|
||||
- text: <code>binom</code> es una función.
|
||||
testString: 'assert(typeof binom === "function", "<code>binom</code> is a function.");'
|
||||
- text: ' <code>binom(5,3)</code> debe devolver 10.'
|
||||
- text: ' <code>binom(5,3)</code> debe devolver 10.'
|
||||
testString: 'assert.equal(binom(5, 3), 10, "<code>binom(5,3)</code> should return 10.");'
|
||||
- text: ' <code>binom(7,2)</code> debe devolver 21'.
|
||||
- text: ' <code>binom(7,2)</code> debe devolver 21'
|
||||
testString: 'assert.equal(binom(7, 2), 21, "<code>binom(7,2)</code> should return 21.");'
|
||||
- text: ' <code>binom(10,4)</code> debe devolver 210.'
|
||||
- text: ' <code>binom(10,4)</code> debe devolver 210.'
|
||||
testString: 'assert.equal(binom(10, 4), 210, "<code>binom(10,4)</code> should return 210.");'
|
||||
- text: ' <code>binom(6,1)</code> debe devolver 6.'
|
||||
- text: ' <code>binom(6,1)</code> debe devolver 6.'
|
||||
testString: 'assert.equal(binom(6, 1), 6, "<code>binom(6,1)</code> should return 6.");'
|
||||
- text: ' <code>binom(12,8)</code> debe devolver 495.'
|
||||
- text: ' <code>binom(12,8)</code> debe devolver 495.'
|
||||
testString: 'assert.equal(binom(12, 8), 495, "<code>binom(12,8)</code> should return 495.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,116 +6,116 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Crear un intérprete para un <a href="https://en.wikipedia.org/wiki/Markov algorithm" title="wp: algoritmo de Markov">algoritmo de Markov</a> . </p><p> Las reglas tienen la sintaxis: </p>
|
||||
<p> <ruleset> :: = (( <comment> | <rule> ) <newline> +) * </p>
|
||||
<p> <comment> :: = # { <any character> } </p>
|
||||
<p> <rule> :: = <pattern><whitespace> -> <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 -> apple
|
||||
B -> bag
|
||||
S -> shop
|
||||
T -> the
|
||||
the shop -> my brother
|
||||
a nunca usado -> 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 -> manzana
|
||||
B -> bolsa
|
||||
S -> .shop
|
||||
T -> el
|
||||
la tienda -> mi hermano
|
||||
una regla nunca utilizada -> .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 -> apple
|
||||
WWWW -> con
|
||||
Bgage -> ->. *
|
||||
B -> bolsa
|
||||
->. * -> money
|
||||
W -> WW
|
||||
S -> .shop
|
||||
T -> the
|
||||
la tienda -> mi hermano
|
||||
a nunca usado -> .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 -> _1 +
|
||||
1 + 1 -> 11+
|
||||
Pase para convertir de la división de la multiplicación en
|
||||
suma ordinaria1! ->! 1
|
||||
,! ->! +
|
||||
_! -> _
|
||||
Multiplicación unaria duplicando el lado izquierdo, lado derecho veces1 * 1 -> x, @ y
|
||||
1x -> xX
|
||||
X, -> 1,1
|
||||
X1 -> 1X
|
||||
_x -> _X
|
||||
, x -> , X
|
||||
y1 -> 1y
|
||||
y_ -> _
|
||||
Siguiente fase de aplicación1 @ 1 -> x, @ y
|
||||
1 @ _ -> @_
|
||||
, @ _ ->! _
|
||||
++ -> +
|
||||
Limpieza de terminación para el agregado_1 -> 1
|
||||
1 + _ -> 1
|
||||
_ + _ ->
|
||||
</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 => escribir 1, mover a la derecha, nuevo estado BA0 -> 1B
|
||||
estado A, símbolo 1 => escribir 1, mover a la izquierda, nuevo estado C0A1 -> C01
|
||||
1A1 -> C11
|
||||
estado B, símbolo 0 => escritura 1, mover a la izquierda, nuevo estado A0B0 -> A01
|
||||
1B0 -> A11
|
||||
estado B, símbolo 1 => escribir 1, mover a la derecha, nuevo estado BB1 -> 1B
|
||||
estado C, símbolo 0 => escribir 1, mover a la izquierda, nuevo estado B0C0 -> B01
|
||||
1C0 -> B11
|
||||
estado C, símbolo 1 => escribir 1, mover a la izquierda, halt0C1 -> H01
|
||||
1C1 -> H11
|
||||
</pre>
|
||||
<p> Este conjunto de reglas debe girar </p>
|
||||
<p> <code>000000A000000</code> </p>
|
||||
<p> dentro </p>
|
||||
<p> <code>00011H1111000</code> </p>
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Crear un intérprete para un <a href="https://en.wikipedia.org/wiki/Markov algorithm" title="wp: algoritmo de Markov">algoritmo de Markov</a> . </p><p> Las reglas tienen la sintaxis: </p>
|
||||
<p> <ruleset> :: = (( <comment> | <rule> ) <newline> +) * </p>
|
||||
<p> <comment> :: = # { <any character> } </p>
|
||||
<p> <rule> :: = <pattern><whitespace> -> <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 -> apple
|
||||
B -> bag
|
||||
S -> shop
|
||||
T -> the
|
||||
the shop -> my brother
|
||||
a nunca usado -> 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 -> manzana
|
||||
B -> bolsa
|
||||
S -> .shop
|
||||
T -> el
|
||||
la tienda -> mi hermano
|
||||
una regla nunca utilizada -> .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 -> apple
|
||||
WWWW -> con
|
||||
Bgage -> ->. *
|
||||
B -> bolsa
|
||||
->. * -> money
|
||||
W -> WW
|
||||
S -> .shop
|
||||
T -> the
|
||||
la tienda -> mi hermano
|
||||
a nunca usado -> .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 -> _1 +
|
||||
1 + 1 -> 11+
|
||||
Pase para convertir de la división de la multiplicación en
|
||||
suma ordinaria1! ->! 1
|
||||
,! ->! +
|
||||
_! -> _
|
||||
Multiplicación unaria duplicando el lado izquierdo, lado derecho veces1 * 1 -> x, @ y
|
||||
1x -> xX
|
||||
X, -> 1,1
|
||||
X1 -> 1X
|
||||
_x -> _X
|
||||
, x -> , X
|
||||
y1 -> 1y
|
||||
y_ -> _
|
||||
Siguiente fase de aplicación1 @ 1 -> x, @ y
|
||||
1 @ _ -> @_
|
||||
, @ _ ->! _
|
||||
++ -> +
|
||||
Limpieza de terminación para el agregado_1 -> 1
|
||||
1 + _ -> 1
|
||||
_ + _ ->
|
||||
</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 => escribir 1, mover a la derecha, nuevo estado BA0 -> 1B
|
||||
estado A, símbolo 1 => escribir 1, mover a la izquierda, nuevo estado C0A1 -> C01
|
||||
1A1 -> C11
|
||||
estado B, símbolo 0 => escritura 1, mover a la izquierda, nuevo estado A0B0 -> A01
|
||||
1B0 -> A11
|
||||
estado B, símbolo 1 => escribir 1, mover a la derecha, nuevo estado BB1 -> 1B
|
||||
estado C, símbolo 0 => escribir 1, mover a la izquierda, nuevo estado B0C0 -> B01
|
||||
1C0 -> B11
|
||||
estado C, símbolo 1 => escribir 1, mover a la izquierda, halt0C1 -> H01
|
||||
1C1 -> H11
|
||||
</pre>
|
||||
<p> Este conjunto de reglas debe girar </p>
|
||||
<p> <code>000000A000000</code> </p>
|
||||
<p> dentro </p>
|
||||
<p> <code>00011H1111000</code> </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -126,15 +126,15 @@ estado C, símbolo 1 => escribir 1, mover a la izquierda, halt0C1 -> H01
|
||||
tests:
|
||||
- text: <code>markov</code> es una función.
|
||||
testString: 'assert(typeof markov === "function", "<code>markov</code> is a function.");'
|
||||
- text: ' <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> debería devolver" Compré una bolsa de manzanas de mi hermano ".
|
||||
- text: ' <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> debería devolver" Compré una bolsa de manzanas de mi hermano ".
|
||||
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: ' <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> debería devolver" Compré una bolsa de manzanas en la tienda de T ".
|
||||
- text: ' <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> debería devolver" Compré una bolsa de manzanas en la tienda de T ".
|
||||
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: ' <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> debería devolver" Compré una bolsa de manzanas con mi dinero de la tienda ". '
|
||||
- text: ' <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> debería devolver" Compré una bolsa de manzanas con mi dinero de la tienda ". '
|
||||
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: ' <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> debe devolver" 11111111111111111111 ". '
|
||||
- text: ' <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> debe devolver" 11111111111111111111 ". '
|
||||
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: ' <code>markov(["A0 -> 1B","0A1 -> C01","1A1 -> C11","0B0 -> A01","1B0 -> A11","B1 -> 1B","0C0 -> B01","1C0 -> B11","0C1 -> H01","1C1 -> H11"],"")</code> debe devolver" 00011H1111000 ". '
|
||||
- text: ' <code>markov(["A0 -> 1B","0A1 -> C01","1A1 -> C11","0B0 -> A01","1B0 -> A11","B1 -> 1B","0C0 -> B01","1C0 -> B11","0C1 -> H01","1C1 -> H11"],"")</code> debe devolver" 00011H1111000 ". '
|
||||
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".");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,35 +6,35 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Escribe una función para implementar un intérprete de Brain ****. La función tomará una cadena como parámetro y debería devolver una cadena como salida. Se dan más detalles a continuación : </p>
|
||||
<p> RCBF es un conjunto de compiladores e intérpretes <a href="http://rosettacode.org/wiki/Brainf***" title="Brainf ***">Brainf ***</a> escritos para Rosetta Code en varios idiomas. </p><p> A continuación hay enlaces a cada una de las versiones de RCBF. </p><p> Una implementación solo necesita implementar correctamente las siguientes instrucciones: </p>
|
||||
<p> {| </p>
|
||||
<p> !Mando </p>
|
||||
<p> !Descripción </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>></code> || Mueve el puntero a la derecha </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code><</code> || Mueve el puntero a la izquierda </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>+</code> || Incrementar la celda de memoria debajo del puntero. </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>-</code> || Disminuye la celda de memoria debajo del puntero. </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>.</code> || Muestra el carácter que significa la celda en el puntero. </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>,</code> || Ingrese un carácter y guárdelo en la celda en el puntero </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>[</code> || Salta la coincidencia <code>]</code> si la celda debajo del puntero es 0 </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>]</code> || Saltar de nuevo a la coincidencia <code>[</code> si la celda debajo del puntero no es cero </p>
|
||||
<p> |} </p>
|
||||
<p> Se permite cualquier tamaño de celda, la compatibilidad con EOF ( <u>E</u> nd- <u>O</u> - <u>F</u> ) es opcional, ya que tiene memoria limitada o no limitada. </p>
|
||||
<section id='description'>
|
||||
<p> Escribe una función para implementar un intérprete de Brain ****. La función tomará una cadena como parámetro y debería devolver una cadena como salida. Se dan más detalles a continuación : </p>
|
||||
<p> RCBF es un conjunto de compiladores e intérpretes <a href="http://rosettacode.org/wiki/Brainf***" title="Brainf ***">Brainf ***</a> escritos para Rosetta Code en varios idiomas. </p><p> A continuación hay enlaces a cada una de las versiones de RCBF. </p><p> Una implementación solo necesita implementar correctamente las siguientes instrucciones: </p>
|
||||
<p> {| </p>
|
||||
<p> !Mando </p>
|
||||
<p> !Descripción </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>></code> || Mueve el puntero a la derecha </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code><</code> || Mueve el puntero a la izquierda </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>+</code> || Incrementar la celda de memoria debajo del puntero. </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>-</code> || Disminuye la celda de memoria debajo del puntero. </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>.</code> || Muestra el carácter que significa la celda en el puntero. </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>,</code> || Ingrese un carácter y guárdelo en la celda en el puntero </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>[</code> || Salta la coincidencia <code>]</code> si la celda debajo del puntero es 0 </p>
|
||||
<p> | - </p>
|
||||
<p> | style = "text-align: center" | <code>]</code> || Saltar de nuevo a la coincidencia <code>[</code> si la celda debajo del puntero no es cero </p>
|
||||
<p> |} </p>
|
||||
<p> Se permite cualquier tamaño de celda, la compatibilidad con EOF ( <u>E</u> nd- <u>O</u> - <u>F</u> ) es opcional, ya que tiene memoria limitada o no limitada. </p>
|
||||
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -47,11 +47,11 @@ tests:
|
||||
testString: 'assert(typeof brain(bye) === "string", "<code>brain(bye)</code> should return a string");'
|
||||
- text: <html> ' <code>brain("++++++[>++++++++++<-]>+++++.")</code>
|
||||
testString: 'assert.equal(brain("++++++[>++++++++++<-]>+++++."),"A", "<code>brain("++++++[>++++++++++<-]>+++++.")</code should return "A"");'
|
||||
- text: ' <code>brain(bye)</code> debe devolver ¡ <code>Goodbye, World!\\r\\n</code> '
|
||||
- text: ' <code>brain(bye)</code> debe devolver ¡ <code>Goodbye, World!\\r\\n</code> '
|
||||
testString: 'assert.equal(brain(bye), "Goodbye, World!\r\n", "<code>brain(bye)</code> should return <code>Goodbye, World!\\r\\n</code>");'
|
||||
- text: <code>brain(hello)</code> debería devolver <code>Hello World!\\n</code> '
|
||||
- text: <code>brain(hello)</code> debería devolver <code>Hello World!\\n</code> '
|
||||
testString: 'assert.equal(brain(hello), "Hello World!\n", "<code>brain(hello)</code> should return <code>Hello World!\\n</code>");'
|
||||
- text: ' <code>brain(fib)</code> debe devolver <code>1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89</code> '
|
||||
- text: ' <code>brain(fib)</code> debe devolver <code>1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89</code> '
|
||||
testString: 'assert.equal(brain(fib), "1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89", "<code>brain(fib)</code> should return <code>1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,22 +6,22 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Escribe una función para devolver el factorial de un número. </p>
|
||||
<p> El factorial de un número viene dado por: </p>
|
||||
n! = n * (n-1) * (n-2) * ..... * 1
|
||||
<p>
|
||||
Por ejemplo:
|
||||
3! = 3 * 2 * 1 = 6
|
||||
4! = 4 * 3 * 2 * 1 = 24
|
||||
</p>
|
||||
<p> Nota:
|
||||
0! = 1
|
||||
</p>
|
||||
<section id='description'>
|
||||
<p> Escribe una función para devolver el factorial de un número. </p>
|
||||
<p> El factorial de un número viene dado por: </p>
|
||||
n! = n * (n-1) * (n-2) * ..... * 1
|
||||
<p>
|
||||
Por ejemplo:
|
||||
3! = 3 * 2 * 1 = 6
|
||||
4! = 4 * 3 * 2 * 1 = 24
|
||||
</p>
|
||||
<p> Nota:
|
||||
0! = 1
|
||||
</p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -38,7 +38,7 @@ tests:
|
||||
testString: 'assert.equal(factorial(3),results[0],"<code>factorial(3)</code> should return 6.");'
|
||||
- text: <code>factorial(3)</code> debe devolver 120. ")
|
||||
testString: 'assert.equal(factorial(5),results[1],"<code>factorial(3)</code> should return 120.");'
|
||||
- text: ' <code>factorial(3)</code> debe devolver 3,628,800. ")'
|
||||
- text: ' <code>factorial(3)</code> debe devolver 3,628,800. ")'
|
||||
testString: 'assert.equal(factorial(10),results[2],"<code>factorial(3)</code> should return 3,628,800.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,13 +6,13 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Escribe una función que devuelva los factores de un entero positivo. </p><p> Estos factores son los enteros positivos por los cuales el número que se factoriza puede dividirse para obtener un resultado entero positivo. </p>
|
||||
///
|
||||
<section id='description'>
|
||||
<p> Escribe una función que devuelva los factores de un entero positivo. </p><p> Estos factores son los enteros positivos por los cuales el número que se factoriza puede dividirse para obtener un resultado entero positivo. </p>
|
||||
///
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -23,11 +23,11 @@ challengeType: 5
|
||||
tests:
|
||||
- text: <code>factors</code> son una función.
|
||||
testString: 'assert(typeof factors === "function", "<code>factors</code> is a function.");'
|
||||
- text: 'Los <code>factors(45)</code> deben devolver <code>[1,3,5,9,15,45]</code> .'
|
||||
- text: 'Los <code>factors(45)</code> deben devolver <code>[1,3,5,9,15,45]</code> .'
|
||||
testString: 'assert.deepEqual(factors(45), ans[0], "<code>factors(45)</code> should return <code>[1,3,5,9,15,45]</code>.");'
|
||||
- text: Los ' <code>factors(53)</code> deben devolver <code>[1,53]</code> .'
|
||||
- text: Los ' <code>factors(53)</code> deben devolver <code>[1,53]</code> .'
|
||||
testString: 'assert.deepEqual(factors(53), ans[1], "<code>factors(53)</code> should return <code>[1,53]</code>.");'
|
||||
- text: Los ' <code>factors(64)</code> deberían devolver <code>[1,2,4,8,16,32,64]</code> .'
|
||||
- text: Los ' <code>factors(64)</code> deberían devolver <code>[1,2,4,8,16,32,64]</code> .'
|
||||
testString: 'assert.deepEqual(factors(64), ans[2], "<code>factors(64)</code> should return <code>[1,2,4,8,16,32,64]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,24 +6,24 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Escriba una función que devuelva la secuencia Farey de orden n. La función debe tener un parámetro que sea n. Debe devolver la secuencia como una matriz. Lea lo siguiente para más detalles : </p><p> La <a href="https://en.wikipedia.org/wiki/Farey sequence" title="wp: secuencia de Farey">secuencia Farey</a> F <sub>n</sub> de orden n es la secuencia de fracciones completamente reducidas entre 0 y 1 que, cuando están en los términos más bajos, tienen denominadores menores o iguales a n, dispuestos en orden creciente de tamaño. </p><p> La secuencia de Farey a veces se llama incorrectamente una serie de Farey. </p>
|
||||
<p> Cada secuencia de Farey: </p>
|
||||
<p> :: * comienza con el valor 0, indicado por la fracción $ \ frac {0} {1} $ </p>
|
||||
<p> :: * termina con el valor 1, indicado por la fracción $ \ frac {1} {1} $. </p>
|
||||
<p> Las secuencias de Farey de las órdenes 1 a 5 son: </p><p> $ {\ bf \ it {F}} _ 1 = \ frac {0} {1}, \ frac {1} {1} $ </p>
|
||||
<p> </p>
|
||||
<p> $ {\ bf \ it {F}} _ 2 = \ frac {0} {1}, \ frac {1} {2}, \ frac {1} {1} $ </p>
|
||||
<p> </p>
|
||||
<p> $ {\ bf \ it {F}} _ 3 = \ frac {0} {1}, \ frac {1} {3}, \ frac {1} {2}, \ frac {2} {3}, \ frac {1} {1} $ </p>
|
||||
<p> </p>
|
||||
<p> $ {\ bf \ it {F}} _ 4 = \ frac {0} {1}, \ frac {1} {4}, \ frac {1} {3}, \ frac {1} {2}, \ frac {2} {3}, \ frac {3} {4}, \ frac {1} {1} $ </p>
|
||||
<p> </p>
|
||||
<p> $ {\ bf \ it {F}} _ 5 = \ frac {0} {1}, \ frac {1} {5}, \ frac {1} {4}, \ frac {1} {3}, \ frac {2} {5}, \ frac {1} {2}, \ frac {3} {5}, \ frac {2} {3}, \ frac {3} {4}, \ frac {4} {5 }, \ frac {1} {1} $ </p>
|
||||
<section id='description'>
|
||||
<p> Escriba una función que devuelva la secuencia Farey de orden n. La función debe tener un parámetro que sea n. Debe devolver la secuencia como una matriz. Lea lo siguiente para más detalles : </p><p> La <a href="https://en.wikipedia.org/wiki/Farey sequence" title="wp: secuencia de Farey">secuencia Farey</a> F <sub>n</sub> de orden n es la secuencia de fracciones completamente reducidas entre 0 y 1 que, cuando están en los términos más bajos, tienen denominadores menores o iguales a n, dispuestos en orden creciente de tamaño. </p><p> La secuencia de Farey a veces se llama incorrectamente una serie de Farey. </p>
|
||||
<p> Cada secuencia de Farey: </p>
|
||||
<p> :: * comienza con el valor 0, indicado por la fracción $ \ frac {0} {1} $ </p>
|
||||
<p> :: * termina con el valor 1, indicado por la fracción $ \ frac {1} {1} $. </p>
|
||||
<p> Las secuencias de Farey de las órdenes 1 a 5 son: </p><p> $ {\ bf \ it {F}} _ 1 = \ frac {0} {1}, \ frac {1} {1} $ </p>
|
||||
<p> </p>
|
||||
<p> $ {\ bf \ it {F}} _ 2 = \ frac {0} {1}, \ frac {1} {2}, \ frac {1} {1} $ </p>
|
||||
<p> </p>
|
||||
<p> $ {\ bf \ it {F}} _ 3 = \ frac {0} {1}, \ frac {1} {3}, \ frac {1} {2}, \ frac {2} {3}, \ frac {1} {1} $ </p>
|
||||
<p> </p>
|
||||
<p> $ {\ bf \ it {F}} _ 4 = \ frac {0} {1}, \ frac {1} {4}, \ frac {1} {3}, \ frac {1} {2}, \ frac {2} {3}, \ frac {3} {4}, \ frac {1} {1} $ </p>
|
||||
<p> </p>
|
||||
<p> $ {\ bf \ it {F}} _ 5 = \ frac {0} {1}, \ frac {1} {5}, \ frac {1} {4}, \ frac {1} {3}, \ frac {2} {5}, \ frac {1} {2}, \ frac {3} {5}, \ frac {2} {3}, \ frac {3} {4}, \ frac {4} {5 }, \ frac {1} {1} $ </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -36,11 +36,11 @@ tests:
|
||||
testString: 'assert(typeof farey === "function", "<code>farey</code> is a function.");'
|
||||
- text: <code>farey(3)</code> debería devolver una matriz
|
||||
testString: 'assert(Array.isArray(farey(3)), "<code>farey(3)</code> should return an array");'
|
||||
- text: ' <code>farey(3)</code> debe devolver <code>["1/3","1/2","2/3"]</code> '
|
||||
- text: ' <code>farey(3)</code> debe devolver <code>["1/3","1/2","2/3"]</code> '
|
||||
testString: 'assert.deepEqual(farey(3), ["1/3","1/2","2/3"], "<code>farey(3)</code> should return <code>["1/3","1/2","2/3"]</code>");'
|
||||
- text: ' <code>farey(4)</code> debe devolver <code>["1/4","1/3","1/2","2/4","2/3","3/4"]</code> '
|
||||
- text: ' <code>farey(4)</code> debe devolver <code>["1/4","1/3","1/2","2/4","2/3","3/4"]</code> '
|
||||
testString: 'assert.deepEqual(farey(4), ["1/4","1/3","1/2","2/4","2/3","3/4"], "<code>farey(4)</code> should return <code>["1/4","1/3","1/2","2/4","2/3","3/4"]</code>");'
|
||||
- text: ' <code>farey(5)</code> debe devolver <code>["1/5","1/4","1/3","2/5","1/2","2/4","3/5","2/3","3/4","4/5"]</code> '
|
||||
- text: ' <code>farey(5)</code> debe devolver <code>["1/5","1/4","1/3","2/5","1/2","2/4","3/5","2/3","3/4","4/5"]</code> '
|
||||
testString: 'assert.deepEqual(farey(5), ["1/5","1/4","1/3","2/5","1/2","2/4","3/5","2/3","3/4","4/5"], "<code>farey(5)</code> should return <code>["1/5","1/4","1/3","2/5","1/2","2/4","3/5","2/3","3/4","4/5"]</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,11 +6,11 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Escribe una función para generar secuencias numéricas de Fibonacci n-step y secuencias de Lucas. El primer parámetro será n. El segundo parámetro será el número de elementos a devolver. El tercer parámetro especificará si se debe generar la secuencia de Fibonacci o la secuencia de Lucas. Si el parámetro es "f", devuelva la secuencia de Fibonacci y si es "l", devuelva la secuencia de Lucas. Las secuencias deben devolverse como una matriz. Se dan más detalles a continuación : </p><p> Estas series de números son una expansión de la <a href="http://rosettacode.org/wiki/Fibonacci sequence" title="secuencia Fibonacci">secuencia de Fibonacci</a> ordinaria donde: </p>
|
||||
Para $ n = 2 $ tenemos la secuencia de Fibonacci; con los valores iniciales $ [1, 1] $ y $ F_k ^ 2 = F_ {k-1} ^ 2 + F_ {k-2} ^ 2 $
|
||||
Para $ n = 3 $ tenemos la secuencia tribonacci; con valores iniciales $ [1, 1, 2] $ y $ F_k ^ 3 = F_ {k-1} ^ 3 + F_ {k-2} ^ 3 + F_ {k-3} ^ 3 $
|
||||
Para $ n = 4 $ tenemos la secuencia tetranacci; con valores iniciales $ [1, 1, 2, 4] $ y $ F_k ^ 4 = F_ {k-1} ^ 4 + F_ {k-2} ^ 4 + F_ {k-3} ^ 4 + F_ {k -4} ^ 4 $ ...
|
||||
<section id='description'>
|
||||
<p> Escribe una función para generar secuencias numéricas de Fibonacci n-step y secuencias de Lucas. El primer parámetro será n. El segundo parámetro será el número de elementos a devolver. El tercer parámetro especificará si se debe generar la secuencia de Fibonacci o la secuencia de Lucas. Si el parámetro es "f", devuelva la secuencia de Fibonacci y si es "l", 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> 2 $ tenemos la secuencia de pasos de Fibonacci $ n $ - $ F_k ^ n $; con valores iniciales de los primeros $ n $ valores de $ (n-1) $ 'th Fibonacci $ n $ -step secuencia $ F_k ^ {n-1} $; y el valor $ k $ 'th de esta secuencia $ n <section id='description'>
|
||||
<p>Write a function to generate Fibonacci n-step number sequences and Lucas sequences. The first parameter will be n. The second parameter will be the number of elements to be returned. The third parameter will specify whether to output the Fibonacci sequence or the Lucas sequence. If the parameter is "f" then return the Fibonacci sequence and if it is "l", then return the Lucas sequence. The sequences must be returned as an array. More details are given below : </p><p>These number series are an expansion of the ordinary <a href="http://rosettacode.org/wiki/Fibonacci sequence" title="Fibonacci sequence">Fibonacci sequence</a> where:</p>
|
||||
For $n = 2$ we have the Fibonacci sequence; with initial values $[1, 1]$ and $F_k^2 = F_{k-1}^2 + F_{k-2}^2$
|
||||
@@ -41,35 +41,35 @@ For general $n>2$ we have the Fibonacci $n$-step sequence - $F_k^n$; with initia
|
||||
<p>| 10 || decanacci || 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ...</p>
|
||||
<p>|}</p><p>Allied sequences can be generated where the initial values are changed:</p>
|
||||
<p> The <a href="https://en.wikipedia.org/wiki/Lucas number" title="wp: Lucas number">Lucas series</a> sums the two preceding values like the fibonacci series for $n=2$ but uses $[2, 1]$ as its initial values.</p><p><!-- Lucas numbers, Lucas number, Lucas series [added to make searches easier.] --></p>
|
||||
</section>#39; th es $ F_k ^ n = \ sum_ {i = 1} ^ {(n)} {F_ {ki} ^ {(n)}} $
|
||||
<p> Para valores pequeños de $ n $, <a href="https://en.wikipedia.org/wiki/Number prefix#Greek_series" title="wp: Número de prefijo # serie_griega">los prefijos numéricos griegos a</a> veces se usan para nombrar individualmente cada serie. </p><p> {| style = "text-align: left;" border = "4" cellpadding = "2" cellspacing = "2" </p>
|
||||
<p> | + Fibonacci $ n $ -step secuencias </p>
|
||||
<p> | - style = "background-color: rgb (255, 204, 255);" </p>
|
||||
<p> ! $ n $ !! Nombre de serie !! Valores </p>
|
||||
<p> | - </p>
|
||||
<p> | 2 || fibonacci || 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 3 || tribonacci || 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 4 || tetranacci || 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 5 || pentanacci || 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 6 || hexanacci || 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 7 || heptanacci || 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 8 || octonacci || 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 9 || nonanacci || 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 10 || decanacci || 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ... </p>
|
||||
<p> |} </p><p> Se pueden generar secuencias aliadas donde se cambian los valores iniciales: </p>
|
||||
<p> La <a href="https://en.wikipedia.org/wiki/Lucas number" title="wp: número de Lucas">serie de Lucas</a> suma los dos valores anteriores como la serie de fibonacci por $ n = 2 $, pero usa $ [2, 1] $ como sus valores iniciales. </p><p><!-- Lucas numbers, Lucas number, Lucas series [added to make searches easier.] --></p>
|
||||
</section>#39; th es $ F_k ^ n = \ sum_ {i = 1} ^ {(n)} {F_ {ki} ^ {(n)}} $
|
||||
<p> Para valores pequeños de $ n $, <a href="https://en.wikipedia.org/wiki/Number prefix#Greek_series" title="wp: Número de prefijo # serie_griega">los prefijos numéricos griegos a</a> veces se usan para nombrar individualmente cada serie. </p><p> {| style = "text-align: left;" border = "4" cellpadding = "2" cellspacing = "2" </p>
|
||||
<p> | + Fibonacci $ n $ -step secuencias </p>
|
||||
<p> | - style = "background-color: rgb (255, 204, 255);" </p>
|
||||
<p> ! $ n $ !! Nombre de serie !! Valores </p>
|
||||
<p> | - </p>
|
||||
<p> | 2 || fibonacci || 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 3 || tribonacci || 1 1 2 4 7 13 24 44 81 149 274 504 927 1705 3136 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 4 || tetranacci || 1 1 2 4 8 15 29 56 108 208 401 773 1490 2872 5536 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 5 || pentanacci || 1 1 2 4 8 16 31 61 120 236 464 912 1793 3525 6930 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 6 || hexanacci || 1 1 2 4 8 16 32 63 125 248 492 976 1936 3840 7617 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 7 || heptanacci || 1 1 2 4 8 16 32 64 127 253 504 1004 2000 3984 7936 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 8 || octonacci || 1 1 2 4 8 16 32 64 128 255 509 1016 2028 4048 8080 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 9 || nonanacci || 1 1 2 4 8 16 32 64 128 256 511 1021 2040 4076 8144 ... </p>
|
||||
<p> | - </p>
|
||||
<p> | 10 || decanacci || 1 1 2 4 8 16 32 64 128 256 512 1023 2045 4088 8172 ... </p>
|
||||
<p> |} </p><p> Se pueden generar secuencias aliadas donde se cambian los valores iniciales: </p>
|
||||
<p> La <a href="https://en.wikipedia.org/wiki/Lucas number" title="wp: número de Lucas">serie de Lucas</a> suma los dos valores anteriores como la serie de fibonacci por $ n = 2 $, pero usa $ [2, 1] $ como sus valores iniciales. </p><p><!-- Lucas numbers, Lucas number, Lucas series [added to make searches easier.] --></p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -80,19 +80,19 @@ For general $n>2$ we have the Fibonacci $n$-step sequence - $F_k^n$; with initia
|
||||
tests:
|
||||
- text: <code>fib_luc</code> es una función.
|
||||
testString: 'assert(typeof fib_luc === "function", "<code>fib_luc</code> is a function.");'
|
||||
- text: ' <code>fib_luc(2,10,"f")</code> debe devolver <code>[1,1,2,3,5,8,13,21,34,55]</code> .'
|
||||
- text: ' <code>fib_luc(2,10,"f")</code> debe devolver <code>[1,1,2,3,5,8,13,21,34,55]</code> .'
|
||||
testString: 'assert.deepEqual(fib_luc(2,10,"f"),ans[0],"<code>fib_luc(2,10,"f")</code> should return <code>[1,1,2,3,5,8,13,21,34,55]</code>.");'
|
||||
- text: ' <code>fib_luc(3,15,"f")</code> debe devolver <code>[1,1,2,4,7,13,24,44,81,149,274,504,927,1705,3136]</code> .'
|
||||
- text: ' <code>fib_luc(3,15,"f")</code> debe devolver <code>[1,1,2,4,7,13,24,44,81,149,274,504,927,1705,3136]</code> .'
|
||||
testString: 'assert.deepEqual(fib_luc(3,15,"f"),ans[1],"<code>fib_luc(3,15,"f")</code> should return <code>[1,1,2,4,7,13,24,44,81,149,274,504,927,1705,3136]</code>.");'
|
||||
- text: ' <code>fib_luc(4,15,"f")</code> debe devolver <code>[1,1,2,4,8,15,29,56,108,208,401,773,1490,2872,5536]</code> .'
|
||||
- text: ' <code>fib_luc(4,15,"f")</code> debe devolver <code>[1,1,2,4,8,15,29,56,108,208,401,773,1490,2872,5536]</code> .'
|
||||
testString: 'assert.deepEqual(fib_luc(4,15,"f"),ans[2],"<code>fib_luc(4,15,"f")</code> should return <code>[1,1,2,4,8,15,29,56,108,208,401,773,1490,2872,5536]</code>.");'
|
||||
- text: ' <code>fib_luc(2,10,"l")</code> debe devolver <code>[ 2, 1, 3, 4, 7, 11, 18, 29, 47, 76]</code> .'
|
||||
- text: ' <code>fib_luc(2,10,"l")</code> debe devolver <code>[ 2, 1, 3, 4, 7, 11, 18, 29, 47, 76]</code> .'
|
||||
testString: 'assert.deepEqual(fib_luc(2,10,"l"),ans[3],"<code>fib_luc(2,10,"l")</code> should return <code>[ 2, 1, 3, 4, 7, 11, 18, 29, 47, 76]</code>.");'
|
||||
- text: ' <code>fib_luc(3,15,"l")</code> debe devolver <code>[ 2, 1, 3, 6, 10, 19, 35, 64, 118, 217, 399, 734, 1350, 2483, 4567 ]</code> .'
|
||||
- text: ' <code>fib_luc(3,15,"l")</code> debe devolver <code>[ 2, 1, 3, 6, 10, 19, 35, 64, 118, 217, 399, 734, 1350, 2483, 4567 ]</code> .'
|
||||
testString: 'assert.deepEqual(fib_luc(3,15,"l"),ans[4],"<code>fib_luc(3,15,"l")</code> should return <code>[ 2, 1, 3, 6, 10, 19, 35, 64, 118, 217, 399, 734, 1350, 2483, 4567 ]</code>.");'
|
||||
- text: ' <code>fib_luc(4,15,"l")</code> debe devolver <code>[ 2, 1, 3, 6, 12, 22, 43, 83, 160, 308, 594, 1145, 2207, 4254, 8200 ]</code> .'
|
||||
- text: ' <code>fib_luc(4,15,"l")</code> debe devolver <code>[ 2, 1, 3, 6, 12, 22, 43, 83, 160, 308, 594, 1145, 2207, 4254, 8200 ]</code> .'
|
||||
testString: 'assert.deepEqual(fib_luc(4,15,"l"),ans[5],"<code>fib_luc(4,15,"l")</code> should return <code>[ 2, 1, 3, 6, 12, 22, 43, 83, 160, 308, 594, 1145, 2207, 4254, 8200 ]</code>.");'
|
||||
- text: ' <code>fib_luc(5,15,"l")</code> debe devolver <code>[ 2, 1, 3, 6, 12, 24, 46, 91, 179, 352, 692, 1360, 2674, 5257, 10335 ]</code> .'
|
||||
- text: ' <code>fib_luc(5,15,"l")</code> debe devolver <code>[ 2, 1, 3, 6, 12, 24, 46, 91, 179, 352, 692, 1360, 2674, 5257, 10335 ]</code> .'
|
||||
testString: 'assert.deepEqual(fib_luc(5,15,"l"),ans[6],"<code>fib_luc(5,15,"l")</code> should return <code>[ 2, 1, 3, 6, 12, 24, 46, 91, 179, 352, 692, 1360, 2674, 5257, 10335 ]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 3
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<div class="rosetta"> <p class="rosetta__paragraph"> <span class="rosetta__text--bold"><a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/FRACTRAN" title="wp: FRACTRAN">FRACTRAN</a></span> es un lenguaje de programación esotérico completo de Turing inventado por el matemático <a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/John Horton Conway" title="wp: John Horton Conway">John Horton Conway</a> . </p><br/><p class="rosetta__paragraph"> Un programa FRACTRAN es una lista ordenada de fracciones positivas $ P = (f_1, f_2, \ ldots, f_m) $, junto con una entrada de entero positiva inicial $ n $. </p>
|
||||
<br/> <p class="rosetta__paragraph"> El programa se ejecuta actualizando el entero $ n $ de la siguiente manera: </p><br/><ul class="rosetta__unordered-list"><li class="rosetta__list-item--unordered"> para la primera fracción, $ f_i $, en la lista para la cual $ nf_i $ es un número entero, reemplace $ n $ con $ nf_i $; </li>
|
||||
<li class="rosetta__list-item--unordered"> repita esta regla hasta que ninguna fracción de la lista produzca un número entero cuando se multiplique por $ n $, luego detenga. </li></ul>
|
||||
<br>
|
||||
<p class="rosetta__paragraph"> Conway dio un programa para primos en FRACTRAN: </p><br/><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 17/91 $, $ 78/85 $, $ 19/51 $, $ 23/38 $, $ 29/33 $, $ 77/29 $, $ 95/23 $, $ 77/19 $, $ 1/17 $, $ 11/13 $, $ 13/11 $, $ 15/14 $, $ 15/2 $, $ 55/1 $</span> </p><br/><p class="rosetta__paragraph"> Comenzando con $ n = 2 $, este programa de FRACTRAN cambiará de $ n $ a $ 15 = 2 \ times (15/2) $, luego $ 825 = 15 \ times (55/1) $, generando la siguiente secuencia de enteros: </p><br/><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 2 $, $ 15 $, $ 825 $, $ 725 $, $ 1925 $, $ 2275 $, $ 425 $, $ 390 $, $ 330 $, $ 290 $, $ 770 $, $ \ ldots $</span> </p><br/><p class="rosetta__paragraph"> Después de 2, esta secuencia contiene las siguientes potencias de 2: </p><br/><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 2 ^ 2 = 4 $, $ 2 ^ 3 = 8 $, $ 2 ^ 5 = 32 $, $ 2 ^ 7 = 128 $, $ 2 ^ {11} = 2048 $, $ 2 ^ {13} = 8192 $, $ 2 ^ {17 } = 131072 $, $ 2 ^ {19} = 524288 $, $ \ ldots $</span> </p><br/><p class="rosetta__paragraph"> cuales son las primeras potencias de 2. </p>
|
||||
<br/> <dl class="rosetta__description-list"><dt class="rosetta__description-title"> Tarea: </dt></dl>
|
||||
<p class="rosetta__paragraph"> Escriba una función que tome un programa de fractran como un parámetro de cadena y devuelva los primeros 10 números del programa como una matriz. Si el resultado no tiene 10 números, devuelva los números como están. </p></div>
|
||||
<section id='description'>
|
||||
<div class="rosetta"> <p class="rosetta__paragraph"> <span class="rosetta__text--bold"><a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/FRACTRAN" title="wp: FRACTRAN">FRACTRAN</a></span> es un lenguaje de programación esotérico completo de Turing inventado por el matemático <a class="rosetta__link--wiki" href="https://en.wikipedia.org/wiki/John Horton Conway" title="wp: John Horton Conway">John Horton Conway</a> . </p><br/><p class="rosetta__paragraph"> Un programa FRACTRAN es una lista ordenada de fracciones positivas $ P = (f_1, f_2, \ ldots, f_m) $, junto con una entrada de entero positiva inicial $ n $. </p>
|
||||
<br/> <p class="rosetta__paragraph"> El programa se ejecuta actualizando el entero $ n $ de la siguiente manera: </p><br/><ul class="rosetta__unordered-list"><li class="rosetta__list-item--unordered"> para la primera fracción, $ f_i $, en la lista para la cual $ nf_i $ es un número entero, reemplace $ n $ con $ nf_i $; </li>
|
||||
<li class="rosetta__list-item--unordered"> repita esta regla hasta que ninguna fracción de la lista produzca un número entero cuando se multiplique por $ n $, luego detenga. </li></ul>
|
||||
<br>
|
||||
<p class="rosetta__paragraph"> Conway dio un programa para primos en FRACTRAN: </p><br/><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 17/91 $, $ 78/85 $, $ 19/51 $, $ 23/38 $, $ 29/33 $, $ 77/29 $, $ 95/23 $, $ 77/19 $, $ 1/17 $, $ 11/13 $, $ 13/11 $, $ 15/14 $, $ 15/2 $, $ 55/1 $</span> </p><br/><p class="rosetta__paragraph"> Comenzando con $ n = 2 $, este programa de FRACTRAN cambiará de $ n $ a $ 15 = 2 \ times (15/2) $, luego $ 825 = 15 \ times (55/1) $, generando la siguiente secuencia de enteros: </p><br/><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 2 $, $ 15 $, $ 825 $, $ 725 $, $ 1925 $, $ 2275 $, $ 425 $, $ 390 $, $ 330 $, $ 290 $, $ 770 $, $ \ ldots $</span> </p><br/><p class="rosetta__paragraph"> Después de 2, esta secuencia contiene las siguientes potencias de 2: </p><br/><p class="rosetta__paragraph"> <span class="rosetta__text--indented">$ 2 ^ 2 = 4 $, $ 2 ^ 3 = 8 $, $ 2 ^ 5 = 32 $, $ 2 ^ 7 = 128 $, $ 2 ^ {11} = 2048 $, $ 2 ^ {13} = 8192 $, $ 2 ^ {17 } = 131072 $, $ 2 ^ {19} = 524288 $, $ \ ldots $</span> </p><br/><p class="rosetta__paragraph"> cuales son las primeras potencias de 2. </p>
|
||||
<br/> <dl class="rosetta__description-list"><dt class="rosetta__description-title"> Tarea: </dt></dl>
|
||||
<p class="rosetta__paragraph"> Escriba una función que tome un programa de fractran como un parámetro de cadena y devuelva los primeros 10 números del programa como una matriz. Si el resultado no tiene 10 números, devuelva los números como están. </p></div>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -28,17 +28,17 @@ challengeType: 3
|
||||
tests:
|
||||
- text: <code>fractran</code> debe ser una función.
|
||||
testString: 'assert(typeof fractran=="function","<code>fractran</code> should be a function.");'
|
||||
- text: ' <code>fractran(""+tests[0]+"")</code> debe devolver una matriz.'
|
||||
- text: ' <code>fractran(""+tests[0]+"")</code> debe devolver una matriz.'
|
||||
testString: 'assert(Array.isArray(fractran(tests[0])),"<code>fractran(""+tests[0]+"")</code> should return an array.");'
|
||||
- text: ' <code>fractran(""+tests[0]+"")</code> debe devolver <code>"+JSON.stringify(results[0])+"</code> .'
|
||||
- text: ' <code>fractran(""+tests[0]+"")</code> debe devolver <code>"+JSON.stringify(results[0])+"</code> .'
|
||||
testString: 'assert.deepEqual(fractran(tests[0]),results[0],"<code>fractran(""+tests[0]+"")</code> should return <code>"+JSON.stringify(results[0])+"</code>.");'
|
||||
- text: ' <code>fractran(""+tests[1]+"")</code> debe devolver <code>"+JSON.stringify(results[1])+"</code> .'
|
||||
- text: ' <code>fractran(""+tests[1]+"")</code> debe devolver <code>"+JSON.stringify(results[1])+"</code> .'
|
||||
testString: 'assert.deepEqual(fractran(tests[1]),results[1],"<code>fractran(""+tests[1]+"")</code> should return <code>"+JSON.stringify(results[1])+"</code>.");'
|
||||
- text: ' <code>fractran(""+tests[2]+"")</code> debe devolver <code>"+JSON.stringify(results[2])+"</code> .'
|
||||
- text: ' <code>fractran(""+tests[2]+"")</code> debe devolver <code>"+JSON.stringify(results[2])+"</code> .'
|
||||
testString: 'assert.deepEqual(fractran(tests[2]),results[2],"<code>fractran(""+tests[2]+"")</code> should return <code>"+JSON.stringify(results[2])+"</code>.");'
|
||||
- text: ' <code>fractran(""+tests[3]+"")</code> debe devolver <code>"+JSON.stringify(results[3])+"</code> .'
|
||||
- text: ' <code>fractran(""+tests[3]+"")</code> debe devolver <code>"+JSON.stringify(results[3])+"</code> .'
|
||||
testString: 'assert.deepEqual(fractran(tests[3]),results[3],"<code>fractran(""+tests[3]+"")</code> should return <code>"+JSON.stringify(results[3])+"</code>.");'
|
||||
- text: ' <code>fractran(""+tests[4]+"")</code> debe devolver <code>"+JSON.stringify(results[4])+"</code> .'
|
||||
- text: ' <code>fractran(""+tests[4]+"")</code> debe devolver <code>"+JSON.stringify(results[4])+"</code> .'
|
||||
testString: 'assert.deepEqual(fractran(tests[4]),results[4],"<code>fractran(""+tests[4]+"")</code> should return <code>"+JSON.stringify(results[4])+"</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Implemente un algoritmo (o más) para calcular la función <a href="https://en.wikipedia.org/wiki/Gamma function">Gamma</a> ($ \ Gamma $) (solo en el campo real).
|
||||
La función Gamma se puede definir como:
|
||||
<div style='padding-left: 4em;'> <big><big>$ \ Gamma (x) = \ displaystyle \ int_0 ^ \ infty t ^ {x-1} e ^ {- t} dt $</big></big> </div>
|
||||
<section id='description'>
|
||||
Implemente un algoritmo (o más) para calcular la función <a href="https://en.wikipedia.org/wiki/Gamma function">Gamma</a> ($ \ Gamma $) (solo en el campo real).
|
||||
La función Gamma se puede definir como:
|
||||
<div style='padding-left: 4em;'> <big><big>$ \ Gamma (x) = \ displaystyle \ int_0 ^ \ infty t ^ {x-1} e ^ {- t} dt $</big></big> </div>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -24,17 +24,17 @@ La función Gamma se puede definir como:
|
||||
tests:
|
||||
- text: <code>gamma</code> debe ser una función.
|
||||
testString: 'assert(typeof gamma=="function","<code>gamma</code> should be a function.")'
|
||||
- text: ' <code>gamma("+tests[0]+")</code> debe devolver un número.'
|
||||
- text: ' <code>gamma("+tests[0]+")</code> debe devolver un número.'
|
||||
testString: 'assert(typeof gamma(tests[0])=="number","<code>gamma("+tests[0]+")</code> should return a number.")'
|
||||
- text: ' <code>gamma("+tests[0]+")</code> debe devolver <code>"+results[0]+"</code> .'
|
||||
- text: ' <code>gamma("+tests[0]+")</code> debe devolver <code>"+results[0]+"</code> .'
|
||||
testString: 'assert.equal(gamma(tests[0]),results[0],"<code>gamma("+tests[0]+")</code> should return <code>"+results[0]+"</code>.")'
|
||||
- text: ' <code>gamma("+tests[1]+")</code> debe devolver <code>"+results[1]+"</code> .'
|
||||
- text: ' <code>gamma("+tests[1]+")</code> debe devolver <code>"+results[1]+"</code> .'
|
||||
testString: 'assert.equal(gamma(tests[1]),results[1],"<code>gamma("+tests[1]+")</code> should return <code>"+results[1]+"</code>.")'
|
||||
- text: ' <code>gamma("+tests[2]+")</code> debe devolver <code>"+results[2]+"</code> .'
|
||||
- text: ' <code>gamma("+tests[2]+")</code> debe devolver <code>"+results[2]+"</code> .'
|
||||
testString: 'assert.equal(gamma(tests[2]),results[2],"<code>gamma("+tests[2]+")</code> should return <code>"+results[2]+"</code>.")'
|
||||
- text: ' <code>gamma("+tests[3]+")</code> debe devolver <code>"+results[3]+"</code> .'
|
||||
- text: ' <code>gamma("+tests[3]+")</code> debe devolver <code>"+results[3]+"</code> .'
|
||||
testString: 'assert.equal(gamma(tests[3]),results[3],"<code>gamma("+tests[3]+")</code> should return <code>"+results[3]+"</code>.")'
|
||||
- text: ' <code>gamma("+tests[4]+")</code> debe devolver <code>"+results[4]+"</code> .'
|
||||
- text: ' <code>gamma("+tests[4]+")</code> debe devolver <code>"+results[4]+"</code> .'
|
||||
testString: 'assert.equal(gamma(tests[4]),results[4],"<code>gamma("+tests[4]+")</code> should return <code>"+results[4]+"</code>.")'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,12 +6,12 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Escriba una función para generar una matriz de caracteres ASCII en minúsculas, para un rango determinado. Por ejemplo: para el rango 1 a 4, la función debe devolver <code>['a','b','c','d']</code> .
|
||||
<section id='description'>
|
||||
Escriba una función para generar una matriz de caracteres ASCII en minúsculas, para un rango determinado. Por ejemplo: para el rango 1 a 4, la función debe devolver <code>['a','b','c','d']</code> .
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -24,15 +24,15 @@ tests:
|
||||
testString: 'assert(typeof lascii=="function","<code>lascii</code> should be a function.");'
|
||||
- text: <code>lascii("a","d")</code> debe devolver una matriz.
|
||||
testString: 'assert(Array.isArray(lascii("a","d")),"<code>lascii("a","d")</code> should return an array.");'
|
||||
- text: '" <code>lascii("a","d")</code> debe devolver <code>[ "a", "b", "c", "d" ]</code> ."'
|
||||
- text: '" <code>lascii("a","d")</code> debe devolver <code>[ "a", "b", "c", "d" ]</code> ."'
|
||||
testString: 'assert.deepEqual(lascii("a","d"),results[0],"<code>lascii("a","d")</code> should return <code>[ "a", "b", "c", "d" ]</code>.");'
|
||||
- text: '" <code>lascii("c","i")</code> debe devolver <code>[ "c", "d", "e", "f", "g", "h", "i" ]</code> ."'
|
||||
- text: '" <code>lascii("c","i")</code> debe devolver <code>[ "c", "d", "e", "f", "g", "h", "i" ]</code> ."'
|
||||
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: '" <code>lascii("m","q")</code> debe devolver <code>[ "m", "n", "o", "p", "q" ]</code> ."'
|
||||
- text: '" <code>lascii("m","q")</code> debe devolver <code>[ "m", "n", "o", "p", "q" ]</code> ."'
|
||||
testString: 'assert.deepEqual(lascii("m","q"),results[2],"<code>lascii("m","q")</code> should return <code>[ "m", "n", "o", "p", "q" ]</code>.");'
|
||||
- text: '" <code>lascii("k","n")</code> debe devolver <code>[ "k", "l", "m", "n" ]</code> .")'
|
||||
- text: '" <code>lascii("k","n")</code> debe devolver <code>[ "k", "l", "m", "n" ]</code> .")'
|
||||
testString: 'assert.deepEqual(lascii("k","n"),results[3],"<code>lascii("k","n")</code> should return <code>[ "k", "l", "m", "n" ]</code>.");'
|
||||
- text: '" <code>lascii("t","z")</code> debe devolver <code>[ "t", "u", "v", "w", "x", "y", "z" ]</code> ."'
|
||||
- text: '" <code>lascii("t","z")</code> debe devolver <code>[ "t", "u", "v", "w", "x", "y", "z" ]</code> ."'
|
||||
testString: 'assert.deepEqual(lascii("t","z"),results[4],"<code>lascii("t","z")</code> should return <code>[ "t", "u", "v", "w", "x", "y", "z" ]</code>.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,21 +6,21 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> La secuencia de números de Hailstone se puede generar a partir de un entero positivo inicial, n mediante: </p>
|
||||
Si n es 1, la secuencia termina.
|
||||
Si n es par, entonces el siguiente n de la secuencia <code>= n/2</code>
|
||||
Si n es impar, entonces el siguiente n de la secuencia <code>= (3 * n) + 1</code> <p> La <a href="https://en.wikipedia.org/wiki/Collatz conjecture" title="wp: conjetura de Collatz">conjetura</a> (no probada) de <a href="https://en.wikipedia.org/wiki/Collatz conjecture" title="wp: conjetura de Collatz">Collatz</a> es que la secuencia de granizo para cualquier número inicial siempre termina. </p>
|
||||
<p> La secuencia de granizo también se conoce como números de granizo (porque los valores suelen estar sujetos a múltiples descensos y ascensos como granizos en una nube), o como la secuencia de Collatz. </p>
|
||||
Tarea:
|
||||
Crea una rutina para generar la secuencia de granizo para un número.
|
||||
Use la rutina para mostrar que la secuencia de granizo para el número 27 tiene 112 elementos que comienzan con <code>27, 82, 41, 124</code> y que terminan con <code>8, 4, 2, 1</code>
|
||||
Muestre el número menos de 100,000 que tiene la secuencia de granizo más larga en conjunto con la longitud de esa secuencia. (¡Pero no muestres la secuencia real!) Ver también:
|
||||
<a href="http://xkcd.com/710" title="enlace: http://xkcd.com/710">xkcd</a> (humorístico).
|
||||
<section id='description'>
|
||||
<p> La secuencia de números de Hailstone se puede generar a partir de un entero positivo inicial, n mediante: </p>
|
||||
Si n es 1, la secuencia termina.
|
||||
Si n es par, entonces el siguiente n de la secuencia <code>= n/2</code>
|
||||
Si n es impar, entonces el siguiente n de la secuencia <code>= (3 * n) + 1</code> <p> La <a href="https://en.wikipedia.org/wiki/Collatz conjecture" title="wp: conjetura de Collatz">conjetura</a> (no probada) de <a href="https://en.wikipedia.org/wiki/Collatz conjecture" title="wp: conjetura de Collatz">Collatz</a> es que la secuencia de granizo para cualquier número inicial siempre termina. </p>
|
||||
<p> La secuencia de granizo también se conoce como números de granizo (porque los valores suelen estar sujetos a múltiples descensos y ascensos como granizos en una nube), o como la secuencia de Collatz. </p>
|
||||
Tarea:
|
||||
Crea una rutina para generar la secuencia de granizo para un número.
|
||||
Use la rutina para mostrar que la secuencia de granizo para el número 27 tiene 112 elementos que comienzan con <code>27, 82, 41, 124</code> y que terminan con <code>8, 4, 2, 1</code>
|
||||
Muestre el número menos de 100,000 que tiene la secuencia de granizo más larga en conjunto con la longitud de esa secuencia. (¡Pero no muestres la secuencia real!) Ver también:
|
||||
<a href="http://xkcd.com/710" title="enlace: http://xkcd.com/710">xkcd</a> (humorístico).
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -31,7 +31,7 @@ Muestre el número menos de 100,000 que tiene la secuencia de granizo más larga
|
||||
tests:
|
||||
- text: <code>hailstoneSequence</code> es una función.
|
||||
testString: 'assert(typeof hailstoneSequence === "function", "<code>hailstoneSequence</code> is a function.");'
|
||||
- text: ' <code>hailstoneSequence()</code> debe devolver <code>[[27,82,41,124,8,4,2,1], [351, 77031]]</code> '
|
||||
- text: ' <code>hailstoneSequence()</code> debe devolver <code>[[27,82,41,124,8,4,2,1], [351, 77031]]</code> '
|
||||
testString: 'assert.deepEqual(hailstoneSequence(), res, "<code>hailstoneSequence()</code> should return <code>[[27,82,41,124,8,4,2,1], [351, 77031]]</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,14 +6,14 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Un número feliz se define mediante el siguiente proceso: </p>
|
||||
<p> Comenzando con cualquier entero positivo, reemplaza el número por la suma de los cuadrados de sus dígitos y repite el proceso hasta que el número sea igual a 1 (donde permanecerá), o se repite sin cesar en un ciclo que no incluye 1. Esos números por lo que este proceso termina en 1 son números felices, mientras que aquellos que no terminan en 1 son números infelices. </p>
|
||||
<p> Implemente una función que devuelva verdadero si el número es feliz o falso si no lo es. </p>
|
||||
<section id='description'>
|
||||
<p> Un número feliz se define mediante el siguiente proceso: </p>
|
||||
<p> Comenzando con cualquier entero positivo, reemplaza el número por la suma de los cuadrados de sus dígitos y repite el proceso hasta que el número sea igual a 1 (donde permanecerá), o se repite sin cesar en un ciclo que no incluye 1. Esos números por lo que este proceso termina en 1 son números felices, mientras que aquellos que no terminan en 1 son números infelices. </p>
|
||||
<p> Implemente una función que devuelva verdadero si el número es feliz o falso si no lo es. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -44,7 +44,7 @@ tests:
|
||||
testString: 'assert(happy(28), "<code>happy(28)</code> should return true.");'
|
||||
- text: <code>happy(31)</code> debe devolver verdadero.
|
||||
testString: 'assert(happy(31), "<code>happy(31)</code> should return true.");'
|
||||
- text: ' <code>happy(32)</code> debe devolver verdadero :.'
|
||||
- text: ' <code>happy(32)</code> debe devolver verdadero :.'
|
||||
testString: 'assert(happy(32), "<code>happy(32)</code> should return true:.");'
|
||||
- text: <code>happy(33)</code> debe devolver falso.
|
||||
testString: 'assert(!happy(33), "<code>happy(33)</code> should return false.");'
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Los números de <a href="http://mathworld.wolfram.com/HarshadNumber.html" title="enlace: http://mathworld.wolfram.com/HarshadNumber.html">Harshad</a> o Niven son enteros positivos ≥ 1 que son divisibles por la suma de sus dígitos. </p><p> Por ejemplo, 42 es un <a href="http://rosettacode.org/wiki/oeis:A005349" title="oeis: a005349">número de Harshad</a> ya que 42 es divisible por (4 + 2) sin resto. </p>
|
||||
Supongamos que la serie se define como los números en orden creciente.
|
||||
Tarea:
|
||||
<p> Implementar una función para generar miembros sucesivos de la secuencia de Harshad. </p><p> Úselo para enumerar los primeros veinte miembros de la secuencia y enumerar el primer número de Harshad mayor que 1000. </p>
|
||||
<section id='description'>
|
||||
<p> Los números de <a href="http://mathworld.wolfram.com/HarshadNumber.html" title="enlace: http://mathworld.wolfram.com/HarshadNumber.html">Harshad</a> o Niven son enteros positivos ≥ 1 que son divisibles por la suma de sus dígitos. </p><p> Por ejemplo, 42 es un <a href="http://rosettacode.org/wiki/oeis:A005349" title="oeis: a005349">número de Harshad</a> ya que 42 es divisible por (4 + 2) sin resto. </p>
|
||||
Supongamos que la serie se define como los números en orden creciente.
|
||||
Tarea:
|
||||
<p> Implementar una función para generar miembros sucesivos de la secuencia de Harshad. </p><p> Úselo para enumerar los primeros veinte miembros de la secuencia y enumerar el primer número de Harshad mayor que 1000. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -25,7 +25,7 @@ Tarea:
|
||||
tests:
|
||||
- text: <code>isHarshadOrNiven</code> es una función.
|
||||
testString: 'assert(typeof isHarshadOrNiven === "function", "<code>isHarshadOrNiven</code> is a function.");'
|
||||
- text: ' <code>isHarshadOrNiven()</code> debe devolver <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> '
|
||||
- text: ' <code>isHarshadOrNiven()</code> debe devolver <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> '
|
||||
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>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,15 +6,15 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Utilizando dos matrices de igual longitud, cree un objeto Hash donde los elementos de una matriz (las claves) estén vinculados a los elementos de la otra (los valores) </p>
|
||||
Tarea relacionada:
|
||||
<a href="http://rosettacode.org/wiki/Associative arrays/Creation" title="Arrays asociativos / Creación">Arreglos asociativos / Creación</a>
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Utilizando dos matrices de igual longitud, cree un objeto Hash donde los elementos de una matriz (las claves) estén vinculados a los elementos de la otra (los valores) </p>
|
||||
Tarea relacionada:
|
||||
<a href="http://rosettacode.org/wiki/Associative arrays/Creation" title="Arrays asociativos / Creación">Arreglos asociativos / Creación</a>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -25,17 +25,17 @@ Tarea relacionada:
|
||||
tests:
|
||||
- text: <code>arrToObj</code> es una función.
|
||||
testString: 'assert(typeof arrToObj === "function", "<code>arrToObj</code> is a function.");'
|
||||
- text: ' <code>arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d", "e"])</code> debe devolver <code>{ 1: "a", 2: "b", 3: "c", 4: "d", 5: "e" }</code> '
|
||||
- text: ' <code>arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d", "e"])</code> debe devolver <code>{ 1: "a", 2: "b", 3: "c", 4: "d", 5: "e" }</code> '
|
||||
testString: 'assert.deepEqual(arrToObj(...testCases[0]), res[0], "<code>arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d", "e"])</code> should return <code>{ 1: "a", 2: "b", 3: "c", 4: "d", 5: "e" }</code>");'
|
||||
- text: ' <code>arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d"])</code> debe devolver <code>{ 1: "a", 2: "b", 3: "c", 4: "d", 5: undefined }</code> '
|
||||
- text: ' <code>arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d"])</code> debe devolver <code>{ 1: "a", 2: "b", 3: "c", 4: "d", 5: undefined }</code> '
|
||||
testString: 'assert.deepEqual(arrToObj(...testCases[1]), res[1], "<code>arrToObj([1, 2, 3, 4, 5], ["a", "b", "c", "d"])</code> should return <code>{ 1: "a", 2: "b", 3: "c", 4: "d", 5: undefined }</code>");'
|
||||
- text: ' <code>arrToObj([1, 2, 3], ["a", "b", "c", "d", "e"])</code> debe devolver <code>{ 1: "a", 2: "b", 3: "c" }</code>
|
||||
- text: ' <code>arrToObj([1, 2, 3], ["a", "b", "c", "d", "e"])</code> debe devolver <code>{ 1: "a", 2: "b", 3: "c" }</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: ' <code>arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4, 5])</code> debe devolver <code>{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": 5 }</code> '
|
||||
- text: ' <code>arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4, 5])</code> debe devolver <code>{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": 5 }</code> '
|
||||
testString: 'assert.deepEqual(arrToObj(...testCases[3]), res[3], "<code>arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4, 5])</code> should return <code>{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": 5 }</code>");'
|
||||
- text: ' <code>arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4])</code> debe devolver <code>{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": undefined }</code> '
|
||||
- text: ' <code>arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4])</code> debe devolver <code>{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": undefined }</code> '
|
||||
testString: 'assert.deepEqual(arrToObj(...testCases[4]), res[4], "<code>arrToObj(["a", "b", "c", "d", "e"], [1, 2, 3, 4])</code> should return <code>{ "a": 1, "b": 2, "c": 3 , "d": 4, "e": undefined }</code>");'
|
||||
- text: ' <code>arrToObj(["a", "b", "c"], [1, 2, 3, 4, 5])</code> debe devolver <code>{ "a": 1, "b": 2, "c": 3 }</code> '
|
||||
- text: ' <code>arrToObj(["a", "b", "c"], [1, 2, 3, 4, 5])</code> debe devolver <code>{ "a": 1, "b": 2, "c": 3 }</code> '
|
||||
testString: 'assert.deepEqual(arrToObj(...testCases[5]), res[5], "<code>arrToObj(["a", "b", "c"], [1, 2, 3, 4, 5])</code> should return <code>{ "a": 1, "b": 2, "c": 3 }</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,164 +6,164 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> Una <a href="https://en.wikipedia.org/wiki/Join_(SQL)#Inner_join" title="wp: Join_ (SQL) #Inner_join">unión interna</a> es una operación que combina dos tablas de datos en una tabla, basada en valores de columna coincidentes. La forma más sencilla de implementar esta operación es el algoritmo de <a href="https://en.wikipedia.org/wiki/Nested loop join" title="wp: unión de bucle anidado">unión de bucle anidado</a> , pero una alternativa más escalable es el algoritmo de <a href="https://en.wikipedia.org/wiki/hash join" title="wp: hash join">combinación de hash</a> . </p>
|
||||
<p> Implemente el algoritmo de "combinación hash" 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 "hash join" 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, "Jonah"], ["Jonah", "Whales"]]</code> . </p><hr>
|
||||
<section id='description'>
|
||||
<p> Una <a href="https://en.wikipedia.org/wiki/Join_(SQL)#Inner_join" title="wp: Join_ (SQL) #Inner_join">unión interna</a> es una operación que combina dos tablas de datos en una tabla, basada en valores de columna coincidentes. La forma más sencilla de implementar esta operación es el algoritmo de <a href="https://en.wikipedia.org/wiki/Nested loop join" title="wp: unión de bucle anidado">unión de bucle anidado</a> , pero una alternativa más escalable es el algoritmo de <a href="https://en.wikipedia.org/wiki/hash join" title="wp: hash join">combinación de hash</a> . </p>
|
||||
<p> Implemente el algoritmo de "combinación hash" 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 "hash join" 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, "Jonah"], ["Jonah", "Whales"]]</code> . </p><hr>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -174,7 +174,7 @@ Caso de prueba
|
||||
tests:
|
||||
- text: <code>hashJoin</code> es una función.
|
||||
testString: 'assert(typeof hashJoin === "function", "<code>hashJoin</code> is a function.");'
|
||||
- text: ' <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> debe devolver <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> '
|
||||
- text: ' <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> debe devolver <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> '
|
||||
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>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,18 +6,18 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p> <a href="https://en.wikipedia.org/wiki/Heron's formula" title="wp: fórmula de Heron">La fórmula del héroe</a> para el área de un triángulo dada la longitud de sus tres lados <big>a,</big> <big>b</big> y <big>c</big> está dada por: </p><p> <big>$ A = \ sqrt {s (sa) (sb) (sc)}, $</big> </p><p> donde <big>s</big> es la mitad del perímetro del triángulo; es decir, </p><p> <big>$ s = \ frac {a + b + c} {2}. $</big> </p>
|
||||
<p> <a href="http://www.had2know.com/academics/heronian-triangles-generator-calculator.html" title="enlace: http://www.had2know.com/academics/heronian-triangles-generator-calculator.html">Los triángulos heronianos</a> son triángulos cuyos lados y área son todos enteros. </p>
|
||||
<p> Un ejemplo es el triángulo con lados 3, 4, 5 cuya área es 6 (y cuyo perímetro es 12). </p>
|
||||
<p> Tenga en cuenta que cualquier triángulo cuyos lados son todos un entero múltiplo de 3, 4, 5; como 6, 8, 10, también será un triángulo heroniano. </p><p> Define un triángulo heroniano primitivo como un triángulo heroniano donde el mayor divisor común </p>
|
||||
<p> De los tres lados es 1 (unidad). </p><p> Esto excluirá, por ejemplo, el triángulo 6, 8, 10. </p>
|
||||
Tarea:
|
||||
<p> Implementar una función basada en la fórmula de héroe que devuelve el primero <code>n <sub>th</sub></code> triángulos ordenadas en una matriz de matrices. </p>
|
||||
<section id='description'>
|
||||
<p> <a href="https://en.wikipedia.org/wiki/Heron's formula" title="wp: fórmula de Heron">La fórmula del héroe</a> para el área de un triángulo dada la longitud de sus tres lados <big>a,</big> <big>b</big> y <big>c</big> está dada por: </p><p> <big>$ A = \ sqrt {s (sa) (sb) (sc)}, $</big> </p><p> donde <big>s</big> es la mitad del perímetro del triángulo; es decir, </p><p> <big>$ s = \ frac {a + b + c} {2}. $</big> </p>
|
||||
<p> <a href="http://www.had2know.com/academics/heronian-triangles-generator-calculator.html" title="enlace: http://www.had2know.com/academics/heronian-triangles-generator-calculator.html">Los triángulos heronianos</a> son triángulos cuyos lados y área son todos enteros. </p>
|
||||
<p> Un ejemplo es el triángulo con lados 3, 4, 5 cuya área es 6 (y cuyo perímetro es 12). </p>
|
||||
<p> Tenga en cuenta que cualquier triángulo cuyos lados son todos un entero múltiplo de 3, 4, 5; como 6, 8, 10, también será un triángulo heroniano. </p><p> Define un triángulo heroniano primitivo como un triángulo heroniano donde el mayor divisor común </p>
|
||||
<p> De los tres lados es 1 (unidad). </p><p> Esto excluirá, por ejemplo, el triángulo 6, 8, 10. </p>
|
||||
Tarea:
|
||||
<p> Implementar una función basada en la fórmula de héroe que devuelve el primero <code>n <sub>th</sub></code> triángulos ordenadas en una matriz de matrices. </p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -28,13 +28,13 @@ Tarea:
|
||||
tests:
|
||||
- text: <code>heronianTriangle</code> es una función.
|
||||
testString: 'assert(typeof heronianTriangle === "function", "<code>heronianTriangle</code> is a function.");'
|
||||
- text: ' <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> '
|
||||
- text: ' <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17]]</code> '
|
||||
testString: 'assert.deepEqual(heronianTriangle(testCases[0]), res[0], "<code>heronianTriangle()</code> should return <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17]]</code>");'
|
||||
- text: ' <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15]],</code>
|
||||
- text: ' <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15]],</code>
|
||||
testString: 'assert.deepEqual(heronianTriangle(testCases[1]), res[1], "<code>heronianTriangle()</code> should return <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15]],</code>");'
|
||||
- text: ' <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> '
|
||||
- text: ' <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53]],</code> '
|
||||
testString: 'assert.deepEqual(heronianTriangle(testCases[2]), res[2], "<code>heronianTriangle()</code> should return <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53]],</code>");'
|
||||
- text: ' <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> '
|
||||
- text: ' <code>heronianTriangle()</code> debe devolver <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53], [19, 20, 37],[16, 17, 17], [17, 17, 30], [16, 25, 39], [13, 20, 21]]</code> '
|
||||
testString: 'assert.deepEqual(heronianTriangle(testCases[3]), res[3], "<code>heronianTriangle()</code> should return <code>[[3, 4, 5], [5, 5, 6], [5, 5, 8], [4, 13, 15], [5, 12, 13], [9, 10, 17], [3, 25, 26], [7, 15, 20], [10, 13, 13], [8, 15, 17], [13, 13, 24], [6, 25, 29], [11, 13, 20], [5, 29, 30], [13, 14, 15], [10, 17, 21], [7, 24, 25], [8, 29, 35], [12, 17, 25], [4, 51, 53], [19, 20, 37],[16, 17, 17], [17, 17, 30], [16, 25, 39], [13, 20, 21]]</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,50 +6,50 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p>
|
||||
<a href="https://en.wikipedia.org/wiki/S-Expression" title="wp: S-Expresión">S-Expressions</a> son una forma conveniente de analizar y almacenar datos.
|
||||
</p>
|
||||
Tarea:
|
||||
<p>
|
||||
Escriba un lector / analizador simple para S-Expressions que maneje cadenas, enteros y flotantes entre comillas y sin comillas.
|
||||
</p>
|
||||
<p>
|
||||
La función debe leer una expresión-S única pero anidada de una cadena y
|
||||
devolverla como una matriz (anidada).
|
||||
</p>
|
||||
<p>
|
||||
líneas nuevas y otros espacios en blanco pueden ignorarse a menos que estén dentro de una cadena entre comillas.
|
||||
</p>
|
||||
<p> “ <tt>()</tt> ” Dentro de las cadenas entre comillas no se interpretan, sino que se tratan como parte de la cadena.
|
||||
</p>
|
||||
<p>
|
||||
manejo de citas escapadas dentro de una cadena es opcional; por lo tanto, " <tt>(foo" barra)</tt> "puede tratarse como una cadena" <tt>foo "barra</tt> ", o como un error.
|
||||
</p>
|
||||
<p>
|
||||
Para esto, el lector no necesita reconocer " <tt>\</tt> " 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 " <tt>()"</tt> "(" <tt>\</tt> "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 "datos citados" 123 4.5)
|
||||
(datos (! @ # (4.5) "(más" "datos)")))
|
||||
</pre>
|
||||
</p>
|
||||
<p>
|
||||
y convertirlo en una estructura de datos nativa. (vea las implementaciones de
|
||||
<a href="http://rosettacode.org/wiki/#Pike" title="#Lucio">Pike</a> ,
|
||||
<a href="http://rosettacode.org/wiki/#Python" title="#Pitón">Python</a> y
|
||||
<a href="http://rosettacode.org/wiki/#Ruby" title="#Rubí">Ruby</a>
|
||||
para ver ejemplos de estructuras de datos nativas).
|
||||
</p>
|
||||
<section id='description'>
|
||||
<p>
|
||||
<a href="https://en.wikipedia.org/wiki/S-Expression" title="wp: S-Expresión">S-Expressions</a> son una forma conveniente de analizar y almacenar datos.
|
||||
</p>
|
||||
Tarea:
|
||||
<p>
|
||||
Escriba un lector / analizador simple para S-Expressions que maneje cadenas, enteros y flotantes entre comillas y sin comillas.
|
||||
</p>
|
||||
<p>
|
||||
La función debe leer una expresión-S única pero anidada de una cadena y
|
||||
devolverla como una matriz (anidada).
|
||||
</p>
|
||||
<p>
|
||||
líneas nuevas y otros espacios en blanco pueden ignorarse a menos que estén dentro de una cadena entre comillas.
|
||||
</p>
|
||||
<p> “ <tt>()</tt> ” Dentro de las cadenas entre comillas no se interpretan, sino que se tratan como parte de la cadena.
|
||||
</p>
|
||||
<p>
|
||||
manejo de citas escapadas dentro de una cadena es opcional; por lo tanto, " <tt>(foo" barra)</tt> "puede tratarse como una cadena" <tt>foo "barra</tt> ", o como un error.
|
||||
</p>
|
||||
<p>
|
||||
Para esto, el lector no necesita reconocer " <tt>\</tt> " 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 " <tt>()"</tt> "(" <tt>\</tt> "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 "datos citados" 123 4.5)
|
||||
(datos (! @ # (4.5) "(más" "datos)")))
|
||||
</pre>
|
||||
</p>
|
||||
<p>
|
||||
y convertirlo en una estructura de datos nativa. (vea las implementaciones de
|
||||
<a href="http://rosettacode.org/wiki/#Pike" title="#Lucio">Pike</a> ,
|
||||
<a href="http://rosettacode.org/wiki/#Python" title="#Pitón">Python</a> y
|
||||
<a href="http://rosettacode.org/wiki/#Ruby" title="#Rubí">Ruby</a>
|
||||
para ver ejemplos de estructuras de datos nativas).
|
||||
</p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -60,7 +60,7 @@ para ver ejemplos de estructuras de datos nativas).
|
||||
tests:
|
||||
- text: <code>parseSexpr</code> es una función.
|
||||
testString: 'assert(typeof parseSexpr === "function", "<code>parseSexpr</code> is a function.");'
|
||||
- text: ' <code>parseSexpr("(data1 data2 data3)")</code> debe devolver ["data1", "data2", "data3"] ")'
|
||||
- text: ' <code>parseSexpr("(data1 data2 data3)")</code> debe devolver ["data1", "data2", "data3"] ")'
|
||||
testString: 'assert.deepEqual(parseSexpr(simpleSExpr), simpleSolution, "<code>parseSexpr("(data1 data2 data3)")</code> should return ["data1", "data2", "data3"]");'
|
||||
- text: <code>parseSexpr('(data1 data2 data3)')</code> debe devolver una matriz con 3 elementos ")
|
||||
testString: 'assert.deepEqual(parseSexpr(basicSExpr), basicSolution, "<code>parseSexpr("(data1 data2 data3)")</code> should return an array with 3 elements");'
|
||||
|
||||
@@ -6,29 +6,29 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Un <a href="https://en.wikipedia.org/wiki/Hardy–Ramanujan number" title="wp: Hardy – número de Ramanujan">número de taxi</a>
|
||||
(la definición que se usa aquí) es un entero positivo que se puede expresar como la suma de dos cubos positivos de más de una manera.
|
||||
El primer número de taxi es 1729, que es:
|
||||
1 <sup>3</sup> + 12 <sup>3</sup> y
|
||||
9 <sup>3</sup> + 10 <sup>3</sup> .
|
||||
números de Taxi también se conocen como:
|
||||
* números de taxi
|
||||
* Los números de taxis
|
||||
* Los números de taxis
|
||||
números * Hardy-Ramanujan
|
||||
Tarea:
|
||||
Escribir una función que devuelve el menor número de taxis N.
|
||||
Para cada uno de los números de taxis, muestre el número y sus cubos constituyentes.
|
||||
Vea también:
|
||||
[http://oeis.org/A001235 A001235 números de taxis] en la Enciclopedia en línea de secuencias de números enteros.
|
||||
<a href="http://mathworld.wolfram.com/Hardy-RamanujanNumber.html">Hardy-Ramanujan Number</a> en MathWorld.
|
||||
<a href="http://mathworld.wolfram.com/TaxicabNumber.html">número de taxi</a> en MathWorld.
|
||||
<a href="https://en.wikipedia.org/wiki/Taxicab_number">número de taxi</a> en Wikipedia.
|
||||
<section id='description'>
|
||||
Un <a href="https://en.wikipedia.org/wiki/Hardy–Ramanujan number" title="wp: Hardy – número de Ramanujan">número de taxi</a>
|
||||
(la definición que se usa aquí) es un entero positivo que se puede expresar como la suma de dos cubos positivos de más de una manera.
|
||||
El primer número de taxi es 1729, que es:
|
||||
1 <sup>3</sup> + 12 <sup>3</sup> y
|
||||
9 <sup>3</sup> + 10 <sup>3</sup> .
|
||||
números de Taxi también se conocen como:
|
||||
* números de taxi
|
||||
* Los números de taxis
|
||||
* Los números de taxis
|
||||
números * Hardy-Ramanujan
|
||||
Tarea:
|
||||
Escribir una función que devuelve el menor número de taxis N.
|
||||
Para cada uno de los números de taxis, muestre el número y sus cubos constituyentes.
|
||||
Vea también:
|
||||
[http://oeis.org/A001235 A001235 números de taxis] en la Enciclopedia en línea de secuencias de números enteros.
|
||||
<a href="http://mathworld.wolfram.com/Hardy-RamanujanNumber.html">Hardy-Ramanujan Number</a> en MathWorld.
|
||||
<a href="http://mathworld.wolfram.com/TaxicabNumber.html">número de taxi</a> en MathWorld.
|
||||
<a href="https://en.wikipedia.org/wiki/Taxicab_number">número de taxi</a> en Wikipedia.
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -43,11 +43,11 @@ tests:
|
||||
testString: 'assert(typeof taxicabNumbers(2) === "object", "<code>taxicabNumbers </code> should return an array.");'
|
||||
- text: <code>taxicabNumbers</code> debe devolver una serie de números.
|
||||
testString: 'assert(typeof taxicabNumbers(100)[0] === "number", "<code>taxicabNumbers </code> should return an array of numbers.");'
|
||||
- text: ' <code>taxicabNumbers(4)</code> debe devolver [1729, 4104, 13832, 20683].'
|
||||
- text: ' <code>taxicabNumbers(4)</code> debe devolver [1729, 4104, 13832, 20683].'
|
||||
testString: 'assert.deepEqual(taxicabNumbers(4), res4, "<code>taxicabNumbers(4) </code> must return [1729, 4104, 13832, 20683].");'
|
||||
- text: '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] '
|
||||
- text: 'taxicabNumbers (25) debe devolver [1729, 4104, 13832, 20683, 32832, 39312, 40033, 46683, 64232, 65728, 110808, 134379, 149389, 165464, 171288, 196041, 216125, 262656, 31446, 320264, 327763, 373464, 402597] '
|
||||
testString: 'assert.deepEqual(taxicabNumbers(25), res25, "taxicabNumbers(25) should return [1729, 4104, 13832, 20683, 32832, 39312, 40033, 46683, 64232, 65728, 110656, 110808, 134379, 149389, 165464, 171288, 195841, 216027, 216125, 262656, 314496, 320264, 327763, 373464, 402597]");'
|
||||
- text: 'taxicabNumbers (39) los números resultantes del 20 al 29 deben ser [314496,320264,327763,373464,402597,439101,443889,513000,513856].'
|
||||
- text: 'taxicabNumbers (39) los números resultantes del 20 al 29 deben ser [314496,320264,327763,373464,402597,439101,443889,513000,513856].'
|
||||
testString: 'assert.deepEqual(taxicabNumbers(39).slice(20, 29), res39From20To29, "taxicabNumbers(39) resulting numbers from 20 - 29 should be [314496,320264,327763,373464,402597,439101,443889,513000,513856].");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,36 +6,36 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
<p>
|
||||
Escriba una función o programa que pueda dividir una cadena en cada aparición sin escape de un carácter separador.
|
||||
</p>
|
||||
<p>
|
||||
Debe aceptar tres parámetros de entrada:
|
||||
</p>
|
||||
La <b>cadena</b>
|
||||
El <b>carácter separador</b>
|
||||
El <b>carácter de escape</b>
|
||||
<p> Debe salir una lista de cadenas. </p>
|
||||
<p> Reglas para dividir: </p>
|
||||
Los campos que estaban separados por los separadores, se convierten en los elementos de la lista de salida.
|
||||
campos vacíos deben conservarse, incluso al principio y al final.
|
||||
<p> Reglas para escapar: </p>
|
||||
"Escapado" 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>
|
||||
['one | uno', ", 'three ^^', 'four ^ | quatro',"]
|
||||
</pre>
|
||||
<section id='description'>
|
||||
<p>
|
||||
Escriba una función o programa que pueda dividir una cadena en cada aparición sin escape de un carácter separador.
|
||||
</p>
|
||||
<p>
|
||||
Debe aceptar tres parámetros de entrada:
|
||||
</p>
|
||||
La <b>cadena</b>
|
||||
El <b>carácter separador</b>
|
||||
El <b>carácter de escape</b>
|
||||
<p> Debe salir una lista de cadenas. </p>
|
||||
<p> Reglas para dividir: </p>
|
||||
Los campos que estaban separados por los separadores, se convierten en los elementos de la lista de salida.
|
||||
campos vacíos deben conservarse, incluso al principio y al final.
|
||||
<p> Reglas para escapar: </p>
|
||||
"Escapado" 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>
|
||||
['one | uno', ", 'three ^^', 'four ^ | quatro',"]
|
||||
</pre>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -48,9 +48,9 @@ tests:
|
||||
testString: 'assert(typeof tokenize === "function", "<code>tokenize</code> is a function.");'
|
||||
- text: <code>tokenize</code> debería devolver una matriz.
|
||||
testString: 'assert(typeof tokenize("a", "b", "c") === "object", "<code>tokenize</code> should return an array.");'
|
||||
- text: ' <code>tokenize("one^|uno||three^^^^|four^^^|^cuatro|", "|", "^")</code> debe devolver ["one | uno", ",, three ^^ "," cuatro ^ | cuatro "," "]") '
|
||||
- text: ' <code>tokenize("one^|uno||three^^^^|four^^^|^cuatro|", "|", "^")</code> debe devolver ["one | uno", ",, three ^^ "," cuatro ^ | cuatro "," "]") '
|
||||
testString: 'assert.deepEqual(tokenize(testStr1, "|", "^"), res1, "<code>tokenize("one^|uno||three^^^^|four^^^|^cuatro|", "|", "^") </code> should return ["one|uno", "", "three^^", "four^|cuatro", ""]");'
|
||||
- text: ' <code>tokenize("a@&bcd&ef&&@@hi", "&", "@")</code> debe devolver <code>["a&bcd", "ef", "", "@hi"]</code> '
|
||||
- text: ' <code>tokenize("a@&bcd&ef&&@@hi", "&", "@")</code> debe devolver <code>["a&bcd", "ef", "", "@hi"]</code> '
|
||||
testString: 'assert.deepEqual(tokenize(testStr2, "&", "@"), res2, "<code>tokenize("a@&bcd&ef&&@@hi", "&", "@")</code> should return <code>["a&bcd", "ef", "", "@hi"]</code>");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,45 +6,45 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Encuentre los mejores datos clasificados de N en cada grupo, donde se proporciona N como parámetro. El nombre del rango y el grupo también se proporcionan como parámetro. </p>
|
||||
Teniendo en cuenta los siguientes datos:
|
||||
<pre>
|
||||
[
|
||||
{nombre: 'Tyler Bennett', id: 'E10297', salario: 32000, departamento: 'D101'},
|
||||
{nombre: 'John Rappl', id: 'E21437', salario: 47000, departamento: ' D050 '},
|
||||
{nombre:' George Woltman ', id:' E00127 ', salario: 53500, dept:' D101 '},
|
||||
{nombre:' Adam Smith ', id:' E63535 ', salario: 18000, dept : 'D202'},
|
||||
{nombre: 'Claire Buckman', id: 'E39876', salario: 27800, dept: 'D202'},
|
||||
{nombre: 'David McClellan', id: 'E04242', salario: 41500 , departamento: 'D101'},
|
||||
{nombre: 'Rich Holcomb', id: 'E01234', salario: 49500, departamento: 'D202'},
|
||||
{nombre: 'Nathan Adams', id: 'E41298', salario : 21900, depto: 'D050'},
|
||||
{nombre: 'Richard Potter', id: 'E43128', salario: 15900, depto: 'D101'},
|
||||
{nombre: 'David Motsinger', id: 'E27002' , salario: 19250, departamento: 'D202'},
|
||||
{nombre: 'Tim Sampair', id: 'E03033', salario: 27000, departamento: 'D101'},
|
||||
{nombre: 'Kim Arlich', id: ' E10001 ', salario: 57000, departamento:' D190 '},
|
||||
{nombre:' Timothy Grove ', id:' E16398 ', salario: 29900, departamento:' D190 '}
|
||||
];
|
||||
</pre>
|
||||
se podrían clasificar los 10 empleados principales en cada departamento llamando a
|
||||
<code>topRankPerGroup(10, data, 'dept', 'salary')</code>
|
||||
Dados los siguientes datos:
|
||||
<pre>
|
||||
[
|
||||
{nombre: 'Viernes 13', género: 'horror', calificación: 9.9},
|
||||
{nombre: "Nightmare on Elm's Street", género: 'horror', calificación: 5.7},
|
||||
{nombre: 'Titanic ', género:' drama ', calificación: 7.3},
|
||||
{nombre:' Maze Runner ', género:' scifi ', calificación: 7.1},
|
||||
{nombre:' Blade runner ', género:' scifi ', calificación: 8.9}
|
||||
];
|
||||
</pre>
|
||||
uno podría clasificar la película mejor calificada en cada género llamando a
|
||||
<code>topRankPerGroup(1, data, 'genre', 'rating')</code>
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Encuentre los mejores datos clasificados de N en cada grupo, donde se proporciona N como parámetro. El nombre del rango y el grupo también se proporcionan como parámetro. </p>
|
||||
Teniendo en cuenta los siguientes datos:
|
||||
<pre>
|
||||
[
|
||||
{nombre: 'Tyler Bennett', id: 'E10297', salario: 32000, departamento: 'D101'},
|
||||
{nombre: 'John Rappl', id: 'E21437', salario: 47000, departamento: ' D050 '},
|
||||
{nombre:' George Woltman ', id:' E00127 ', salario: 53500, dept:' D101 '},
|
||||
{nombre:' Adam Smith ', id:' E63535 ', salario: 18000, dept : 'D202'},
|
||||
{nombre: 'Claire Buckman', id: 'E39876', salario: 27800, dept: 'D202'},
|
||||
{nombre: 'David McClellan', id: 'E04242', salario: 41500 , departamento: 'D101'},
|
||||
{nombre: 'Rich Holcomb', id: 'E01234', salario: 49500, departamento: 'D202'},
|
||||
{nombre: 'Nathan Adams', id: 'E41298', salario : 21900, depto: 'D050'},
|
||||
{nombre: 'Richard Potter', id: 'E43128', salario: 15900, depto: 'D101'},
|
||||
{nombre: 'David Motsinger', id: 'E27002' , salario: 19250, departamento: 'D202'},
|
||||
{nombre: 'Tim Sampair', id: 'E03033', salario: 27000, departamento: 'D101'},
|
||||
{nombre: 'Kim Arlich', id: ' E10001 ', salario: 57000, departamento:' D190 '},
|
||||
{nombre:' Timothy Grove ', id:' E16398 ', salario: 29900, departamento:' D190 '}
|
||||
];
|
||||
</pre>
|
||||
se podrían clasificar los 10 empleados principales en cada departamento llamando a
|
||||
<code>topRankPerGroup(10, data, 'dept', 'salary')</code>
|
||||
Dados los siguientes datos:
|
||||
<pre>
|
||||
[
|
||||
{nombre: 'Viernes 13', género: 'horror', calificación: 9.9},
|
||||
{nombre: "Nightmare on Elm's Street", género: 'horror', calificación: 5.7},
|
||||
{nombre: 'Titanic ', género:' drama ', calificación: 7.3},
|
||||
{nombre:' Maze Runner ', género:' scifi ', calificación: 7.1},
|
||||
{nombre:' Blade runner ', género:' scifi ', calificación: 8.9}
|
||||
];
|
||||
</pre>
|
||||
uno podría clasificar la película mejor calificada en cada género llamando a
|
||||
<code>topRankPerGroup(1, data, 'genre', 'rating')</code>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -63,9 +63,9 @@ tests:
|
||||
testString: 'assert.equal(res1[0][1].salary, 21900, "First department must be D050");'
|
||||
- text: El último departamento debe ser D202.
|
||||
testString: 'assert.equal(res1[3][3].dept, "D202", "The last department must be D202");'
|
||||
- text: ' <code>topRankPerGroup(1, ...)</code> debe devolver solo el resultado de clasificación superior por grupo.'
|
||||
- text: ' <code>topRankPerGroup(1, ...)</code> debe devolver solo el resultado de clasificación superior por grupo.'
|
||||
testString: 'assert.equal(res2[2].length, 1, "<code>topRankPerGroup(1, ...)</code> must return only top ranking result per group.");'
|
||||
- text: ' <code>topRankPerGroup(1, ...)</code> debe devolver solo el resultado de clasificación superior por grupo.'
|
||||
- text: ' <code>topRankPerGroup(1, ...)</code> debe devolver solo el resultado de clasificación superior por grupo.'
|
||||
testString: 'assert.equal(res3[2][1].name, "Maze Runner", "<code>topRankPerGroup(1, ...)</code> must return only top ranking result per group.");'
|
||||
|
||||
```
|
||||
|
||||
@@ -6,22 +6,22 @@ challengeType: 5
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Resuelve el problema de las <a href="https://en.wikipedia.org/wiki/Towers_of_Hanoi" title="wp: torres_de_hanoi">Torres de Hanoi</a> . </p>
|
||||
<p>
|
||||
Su solución debe aceptar el número de discos como los primeros parámetros, y
|
||||
tres cadenas utilizadas para identificar cada una de las tres pilas de discos, por ejemplo
|
||||
<code>towerOfHanoi(4, 'A', 'B', 'C')</code> . La función debe devolver una matriz
|
||||
de matrices que contiene la lista de movimientos, origen -> destino. Para el ejemplo
|
||||
, la matriz <code>[['A', 'C'], ['B', 'A']]</code> indica que el primer movimiento
|
||||
fue mover un disco de la pila A a la C, y el segundo movimiento fue mueve un disco
|
||||
de la pila B a A.
|
||||
</p>
|
||||
<section id='description'>
|
||||
Tarea:
|
||||
<p> Resuelve el problema de las <a href="https://en.wikipedia.org/wiki/Towers_of_Hanoi" title="wp: torres_de_hanoi">Torres de Hanoi</a> . </p>
|
||||
<p>
|
||||
Su solución debe aceptar el número de discos como los primeros parámetros, y
|
||||
tres cadenas utilizadas para identificar cada una de las tres pilas de discos, por ejemplo
|
||||
<code>towerOfHanoi(4, 'A', 'B', 'C')</code> . La función debe devolver una matriz
|
||||
de matrices que contiene la lista de movimientos, origen -> destino. Para el ejemplo
|
||||
, la matriz <code>[['A', 'C'], ['B', 'A']]</code> indica que el primer movimiento
|
||||
fue mover un disco de la pila A a la C, y el segundo movimiento fue mueve un disco
|
||||
de la pila B a A.
|
||||
</p>
|
||||
</section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
<section id='instructions'>
|
||||
|
||||
</section>
|
||||
|
||||
@@ -32,13 +32,13 @@ de la pila B a A.
|
||||
tests:
|
||||
- text: <code>towerOfHanoi</code> es una función.
|
||||
testString: 'assert(typeof towerOfHanoi === "function", "<code>towerOfHanoi</code> is a function.");'
|
||||
- text: ' <code>towerOfHanoi(3, ...)</code> debe devolver 7 movimientos.'
|
||||
- text: ' <code>towerOfHanoi(3, ...)</code> debe devolver 7 movimientos.'
|
||||
testString: 'assert(res3.length === 7, "<code>towerOfHanoi(3, ...)</code> should return 7 moves.");'
|
||||
- text: ' <code>towerOfHanoi(3, "A", "B", "C")</code> debe devolver [["A", "B"], ["A", "C"], ["B", "C"], ["A", "B"], ["C", "A"], ["C", "B"], ["A", "B"]]. ") '
|
||||
- text: ' <code>towerOfHanoi(3, "A", "B", "C")</code> debe devolver [["A", "B"], ["A", "C"], ["B", "C"], ["A", "B"], ["C", "A"], ["C", "B"], ["A", "B"]]. ") '
|
||||
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: ' <code>towerOfHanoi(5, "X", "Y", "Z")</code> décimo movimiento debe ser Y -> X.'
|
||||
- text: ' <code>towerOfHanoi(5, "X", "Y", "Z")</code> décimo movimiento debe ser Y -> X.'
|
||||
testString: 'assert.deepEqual(res5[9], ["Y", "X"], "<code>towerOfHanoi(5, "X", "Y", "Z")</code> 10th move should be Y -> X.");'
|
||||
- text: ' <code>towerOfHanoi(7, "A", "B", "C")</code> primeros diez movimientos son [["A", "B"], ["A", "C"], ["B", "C" ], ["A", "B"], ["C", "A"], ["C", "B"], ["A", "B"], ["A", "C" ], ["B", "C"], ["B", "A"]]. ") '
|
||||
- text: ' <code>towerOfHanoi(7, "A", "B", "C")</code> primeros diez movimientos son [["A", "B"], ["A", "C"], ["B", "C" ], ["A", "B"], ["C", "A"], ["C", "B"], ["A", "B"], ["A", "C" ], ["B", "C"], ["B", "A"]]. ") '
|
||||
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"]].");'
|
||||
|
||||
```
|
||||
|
||||
Reference in New Issue
Block a user