feat: add Spanish and language parser
This commit is contained in:
Beau Carnes
committed by
mrugesh mohapatra
mrugesh mohapatra
parent
c2a45b58be
commit
e3f9dc4b86
@ -1,20 +1,16 @@
|
||||
---
|
||||
id: 587d8257367417b2b2512c7b
|
||||
title: Add a New Element to a Binary Search Tree
|
||||
localeTitle: Agregar un nuevo elemento a un árbol de búsqueda binario
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Agregar un nuevo elemento a un árbol de búsqueda binario
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora que tenemos una idea de lo básico, escribamos un método más complejo.
|
||||
En este desafío, crearemos un método para agregar nuevos valores a nuestro árbol de búsqueda binario. El método debe llamarse <code>add</code> y debe aceptar un valor entero para agregarlo al árbol. Tenga cuidado de mantener el invariante de un árbol de búsqueda binario: el valor en cada elemento secundario izquierdo debe ser menor o igual que el valor principal, y el valor en cada elemento secundario derecho debe ser mayor o igual que el valor principal. Aquí, hagamos que nuestro árbol no pueda contener valores duplicados. Si intentamos agregar un valor que ya existe, el método debe devolver <code>null</code> . De lo contrario, si la adición es exitosa, se debe devolver <code>undefined</code> .
|
||||
Sugerencia: ¡los árboles son naturalmente estructuras de datos recursivas!
|
||||
</section>
|
||||
<section id="description"> Ahora que tenemos una idea de lo básico, escribamos un método más complejo. En este desafío, crearemos un método para agregar nuevos valores a nuestro árbol de búsqueda binario. El método debe llamarse <code>add</code> y debe aceptar un valor entero para agregarlo al árbol. Tenga cuidado de mantener el invariante de un árbol de búsqueda binario: el valor en cada elemento secundario izquierdo debe ser menor o igual que el valor principal, y el valor en cada elemento secundario derecho debe ser mayor o igual que el valor principal. Aquí, hagamos que nuestro árbol no pueda contener valores duplicados. Si intentamos agregar un valor que ya existe, el método debe devolver <code>null</code> . De lo contrario, si la adición es exitosa, se debe devolver <code>undefined</code> . Pista: ¡los árboles son naturalmente estructuras de datos recursivas! </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -52,6 +48,7 @@ function BinarySearchTree() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -71,44 +68,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function Node(value) {
|
||||
this.value = value;
|
||||
this.left = null;
|
||||
this.right = null;
|
||||
}
|
||||
function BinarySearchTree() {
|
||||
this.root = null;
|
||||
this.add = function (element) {
|
||||
let current = this.root;
|
||||
if (!current) {
|
||||
this.root = new Node(element)
|
||||
return;
|
||||
} else {
|
||||
const searchTree = function (current) {
|
||||
if (current.value > element) {
|
||||
if (current.left) { //si existe
|
||||
return searchTree(current.left)
|
||||
} else {
|
||||
current.left = new Node(element);
|
||||
return;
|
||||
}
|
||||
} else if (current.value < element) {
|
||||
if (current.right) {
|
||||
return searchTree(current.right)
|
||||
} else {
|
||||
current.right = new Node(element)
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
return searchTree(current);
|
||||
}
|
||||
}
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 587d8252367417b2b2512c67
|
||||
title: Add Elements at a Specific Index in a Linked List
|
||||
localeTitle: Agregar elementos a un índice específico en una lista enlazada
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Agregar elementos a un índice específico en una lista enlazada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Vamos a crear un método addAt (índice, elemento) que agregue un elemento a un índice dado.
|
||||
Al igual que con la forma en que eliminamos los elementos en un índice determinado, debemos realizar un seguimiento del índice actual mientras recorremos la lista enlazada. Cuando el currentIndex coincida con el índice dado, deberíamos reasignar la siguiente propiedad del nodo anterior para hacer referencia al nuevo nodo agregado. Y el nuevo nodo debe hacer referencia al siguiente nodo en el currentIndex.
|
||||
Volviendo al ejemplo de la línea de conga, una nueva persona quiere unirse a la línea, pero quiere unirse en el medio. Estás en el medio de la línea, así que quitas las manos de la persona que está delante de ti. La nueva persona se acerca y pone sus manos sobre la persona que una vez tuvo, y ahora tiene las manos sobre la nueva persona.
|
||||
Instrucciones
|
||||
Crea un método addAt (índice, elemento) que agregue un elemento a un índice determinado. Devuelve false si un elemento no se pudo agregar.
|
||||
Nota
|
||||
Recuerde verificar si el índice dado es negativo o más largo que la longitud de la lista enlazada.
|
||||
</section>
|
||||
<section id="description"> Vamos a crear un método addAt (índice, elemento) que agregue un elemento a un índice dado. Al igual que con la forma en que eliminamos los elementos en un índice determinado, debemos realizar un seguimiento del índice actual mientras recorremos la lista enlazada. Cuando el currentIndex coincida con el índice dado, deberíamos reasignar la siguiente propiedad del nodo anterior para hacer referencia al nuevo nodo agregado. Y el nuevo nodo debe hacer referencia al siguiente nodo en el currentIndex. Volviendo al ejemplo de la línea de conga, una nueva persona quiere unirse a la línea, pero quiere unirse en el medio. Estás en el medio de la línea, así que quitas las manos de la persona que está delante de ti. La nueva persona se acerca y pone sus manos sobre la persona que una vez tuvo, y ahora tiene las manos sobre la nueva persona. Instrucciones Cree un método addAt (índice, elemento) que agregue un elemento a un índice determinado. Devuelve false si un elemento no se pudo agregar. Nota Recuerde verificar si el índice dado es negativo o más largo que la longitud de la lista enlazada. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -82,6 +74,7 @@ function LinkedList() {
|
||||
// Only change code above this line
|
||||
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,26 +1,16 @@
|
||||
---
|
||||
id: 587d8256367417b2b2512c77
|
||||
title: Adjacency List
|
||||
localeTitle: Lista de adyacencia
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Lista de adyacencia
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
gráficas se pueden representar de diferentes maneras. Aquí describimos una forma, que se llama una <dfn>lista de adyacencia</dfn> .
|
||||
Una lista de adyacencia es esencialmente una lista con viñetas donde el lado izquierdo es el nodo y el lado derecho enumera todos los otros nodos a los que está conectado. A continuación se muestra una representación de una lista de adyacencia.
|
||||
<blockquote>Node1: Node2, Node3<br>Node2: Node1<br>Node3: Node1</blockquote>
|
||||
Arriba hay un gráfico no dirigido porque <code>Node1</code> está conectado a <code>Node2</code> y <code>Node3</code> , y esa información es consistente con las conexiones que muestran <code>Node2</code> y <code>Node3</code> . Una lista de adyacencia para un gráfico dirigido significaría que cada fila de la lista muestra la dirección. Si se dirigió lo anterior, entonces <code>Node2: Node1</code> significaría que el borde dirigido apunta desde <code>Node2</code> hacia <code>Node1</code> .
|
||||
Podemos representar el gráfico no dirigido arriba como una lista de adyacencia colocándolo dentro de un objeto de JavaScript.
|
||||
<blockquote>var undirectedG = {<br> Node1: ["Node2", "Node3"],<br> Node2: ["Node1"],<br> Node3: ["Node1"]<br>};</blockquote>
|
||||
Esto también puede representarse más simplemente como una matriz donde los nodos solo tienen números en lugar de etiquetas de cadena.
|
||||
<blockquote>var undirectedGArr = [<br> [1, 2], # Node1<br> [0], # Node2<br> [0] # Node3<br>];</blockquote>
|
||||
</section>
|
||||
<section id="description"> Los gráficos se pueden representar de diferentes maneras. Aquí describimos una forma, que se llama una <dfn>lista de adyacencia</dfn> . Una lista de adyacencia es esencialmente una lista con viñetas donde el lado izquierdo es el nodo y el lado derecho enumera todos los otros nodos a los que está conectado. A continuación se muestra una representación de una lista de adyacencia. <blockquote> Nodo1: Nodo2, Nodo3 <br> Nodo2: Nodo1 <br> Nodo3: Nodo1 </blockquote> Arriba hay un gráfico no dirigido porque <code>Node1</code> está conectado a <code>Node2</code> y <code>Node3</code> , y esa información es consistente con las conexiones que muestran <code>Node2</code> y <code>Node3</code> . Una lista de adyacencia para un gráfico dirigido significaría que cada fila de la lista muestra la dirección. Si se dirigió lo anterior, entonces <code>Node2: Node1</code> significaría que el borde dirigido apunta desde <code>Node2</code> hacia <code>Node1</code> . Podemos representar el gráfico no dirigido arriba como una lista de adyacencia colocándolo dentro de un objeto de JavaScript. <blockquote> var undirectedG = { <br> Nodo1: ["Nodo2", "Nodo3"], <br> Nodo2: ["Nodo1"], <br> Nodo3: ["Nodo1"] <br> }; </blockquote> Esto también puede representarse más simplemente como una matriz donde los nodos solo tienen números en lugar de etiquetas de cadena. <blockquote> var undirectedGArr = [ <br> [1, 2], # Nodo1 <br> [0], # Nodo2 <br> [0] # Nodo3 <br> ]; </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cree una red social como un gráfico no dirigido con 4 nodos / personas llamadas <code>James</code> , <code>Jill</code> , <code>Jenny</code> y <code>Jeff</code> . Hay bordes / relaciones entre James y Jeff, Jill y Jenny, y Jeff y Jenny.
|
||||
</section>
|
||||
<section id="instructions"> Cree una red social como un gráfico no dirigido con 4 nodos / personas llamadas <code>James</code> , <code>Jill</code> , <code>Jenny</code> y <code>Jeff</code> . Hay bordes / relaciones entre James y Jeff, Jill y Jenny, y Jeff y Jenny. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@ -48,6 +38,7 @@ tests:
|
||||
```js
|
||||
var undirectedAdjList = {
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -59,12 +50,7 @@ var undirectedAdjList = {
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var undirectedAdjList = {
|
||||
"James": ["Jeff"],"Jill": ["Jenny"],"Jenny": ["Jill", "Jeff"],
|
||||
"Jeff": ["James", "Jenny"]
|
||||
};
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,28 +1,16 @@
|
||||
---
|
||||
id: 587d8256367417b2b2512c78
|
||||
title: Adjacency Matrix
|
||||
localeTitle: Matriz de adyacencia
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Matriz de adyacencia
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Otra forma de representar una gráfica es ponerla en una <dfn>matriz de adyacencia</dfn> .
|
||||
Una <dfn>matriz de adyacencia</dfn> es una <dfn>matriz</dfn> bidimensional (2D) donde cada matriz anidada tiene el mismo número de elementos que la matriz externa. En otras palabras, es una matriz o cuadrícula de números, donde los números representan los bordes. Los ceros significan que no hay ventaja o relación.
|
||||
<blockquote> 1 2 3<br> ------<br>1 | 0 1 1<br>2 | 1 0 0<br>3 | 1 0 0</blockquote>
|
||||
Arriba hay un gráfico muy simple, no dirigido, donde tiene tres nodos, donde el primer nodo está conectado al segundo y tercer nodo. <strong>Nota</strong> : Los números en la parte superior e izquierda de la matriz son solo etiquetas para los nodos.
|
||||
A continuación se muestra una implementación de JavaScript de la misma cosa.
|
||||
<blockquote>var adjMat = [<br> [0, 1, 1],<br> [1, 0, 0],<br> [1, 0, 0]<br>];</blockquote>
|
||||
A diferencia de una lista de adyacencia, cada "fila" de la matriz debe tener el mismo número de elementos que los nodos en el gráfico. Aquí tenemos una matriz de tres por tres, lo que significa que tenemos tres nodos en nuestro gráfico.
|
||||
Una gráfica dirigida se vería similar. A continuación se muestra un gráfico donde el primer nodo tiene un borde que apunta hacia el segundo nodo, y luego el segundo nodo tiene un borde que apunta al tercer nodo.
|
||||
<blockquote>var adjMatDirected = [<br> [0, 1, 0],<br> [0, 0, 1],<br> [0, 0, 0]<br>];</blockquote>
|
||||
gráficos también pueden tener <dfn>pesos</dfn> en sus bordes. Hasta ahora, tenemos bordes <dfn>no ponderados</dfn> donde solo la presencia y la falta de borde es binaria ( <code>0</code> o <code>1</code> ). Puede tener diferentes pesos dependiendo de su aplicación.
|
||||
</section>
|
||||
<section id="description"> Otra forma de representar una gráfica es colocarla en una <dfn>matriz de adyacencia</dfn> . Una <dfn>matriz de adyacencia</dfn> es una <dfn>matriz</dfn> bidimensional (2D) donde cada matriz anidada tiene el mismo número de elementos que la matriz externa. En otras palabras, es una matriz o cuadrícula de números, donde los números representan los bordes. Los ceros significan que no hay ventaja o relación. <blockquote> 1 2 3 <br> ------ <br> 1 | 0 1 1 <br> 2 | 1 0 0 <br> 3 | 1 0 0 </blockquote> Arriba hay un gráfico muy simple, no dirigido, donde tiene tres nodos, donde el primer nodo está conectado al segundo y tercer nodo. <strong>Nota</strong> : Los números en la parte superior e izquierda de la matriz son solo etiquetas para los nodos. A continuación se muestra una implementación de JavaScript de la misma cosa. <blockquote> var adjMat = [ <br> [0, 1, 1], <br> [1, 0, 0], <br> [1, 0, 0] <br> ]; </blockquote> A diferencia de una lista de adyacencia, cada "fila" de la matriz debe tener el mismo número de elementos que los nodos en el gráfico. Aquí tenemos una matriz de tres por tres, lo que significa que tenemos tres nodos en nuestro gráfico. Un gráfico dirigido se vería similar. A continuación se muestra un gráfico donde el primer nodo tiene un borde que apunta hacia el segundo nodo, y luego el segundo nodo tiene un borde que apunta al tercer nodo. <blockquote> var adjMatDirected = [ <br> [0, 1, 0], <br> [0, 0, 1], <br> [0, 0, 0] <br> ]; </blockquote> Los gráficos también pueden tener <dfn>pesos</dfn> en sus bordes. Hasta ahora, tenemos bordes <dfn>no ponderados</dfn> donde solo la presencia y la falta de borde es binaria ( <code>0</code> o <code>1</code> ). Puede tener diferentes pesos dependiendo de su aplicación. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cree una matriz de adyacencia de un gráfico no dirigido con cinco nodos. Esta matriz debe estar en una matriz multidimensional. Estos cinco nodos tienen relaciones entre el primer y cuarto nodo, el primer y tercer nodo, el tercer y quinto nodo y el cuarto y quinto nodo. Todos los pesos de los bordes son uno.
|
||||
</section>
|
||||
<section id="instructions"> Cree una matriz de adyacencia de un gráfico no dirigido con cinco nodos. Esta matriz debe estar en una matriz multidimensional. Estos cinco nodos tienen relaciones entre el primer y cuarto nodo, el primer y tercer nodo, el tercer y quinto nodo y el cuarto y quinto nodo. Todos los pesos de los bordes son uno. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@ -52,6 +40,7 @@ tests:
|
||||
```js
|
||||
var adjMatUndirected = [
|
||||
];
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -63,9 +52,7 @@ var adjMatUndirected = [
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var adjMatUndirected = [[0, 0, 1, 1, 0],[0, 0, 0, 0, 0],[1, 0, 0, 0, 1],[1, 0, 0, 0, 1],[0, 0, 1, 1, 0]];
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,41 +1,29 @@
|
||||
---
|
||||
id: 587d825c367417b2b2512c90
|
||||
title: Breadth-First Search
|
||||
localeTitle: Búsqueda de amplitud
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Búsqueda de amplitud
|
||||
---
|
||||
|
||||
## 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>
|
||||
<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. Por ú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>
|
||||
<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
|
||||
<section id='tests'>
|
||||
|
||||
```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> debe 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>");'
|
||||
|
||||
```
|
||||
@ -62,6 +50,7 @@ var exBFSGraph = [
|
||||
[0, 0, 1, 0]
|
||||
];
|
||||
console.log(bfs(exBFSGraph, 3));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -81,39 +70,7 @@ console.info('after the test');
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function bfs(graph, root) {
|
||||
// Distance object returned
|
||||
var nodesLen = {};
|
||||
// Set all distances to infinity
|
||||
for (var i = 0; i < graph.length; i++) {
|
||||
nodesLen[i] = Infinity;
|
||||
}
|
||||
nodesLen[root] = 0; // ...except root node
|
||||
var queue = [root]; // Keep track of nodes to visit
|
||||
var current; // Current node traversing
|
||||
// Keep on going until no more nodes to traverse
|
||||
while (queue.length !== 0) {
|
||||
current = queue.shift();
|
||||
// Get adjacent nodes from current node
|
||||
var curConnected = graph[current]; // Get layer of edges from current
|
||||
var neighborIdx = []; // List of nodes with edges
|
||||
var idx = curConnected.indexOf(1); // Get first edge connection
|
||||
while (idx !== -1) {
|
||||
neighborIdx.push(idx); // Add to list of neighbors
|
||||
idx = curConnected.indexOf(1, idx + 1); // Keep on searching
|
||||
}
|
||||
// Loop through neighbors and get lengths
|
||||
for (var j = 0; j < neighborIdx.length; j++) {
|
||||
// Increment distance for nodes traversed
|
||||
if (nodesLen[neighborIdx[j]] === Infinity) {
|
||||
nodesLen[neighborIdx[j]] = nodesLen[current] + 1;
|
||||
queue.push(neighborIdx[j]); // Add new neighbors to queue
|
||||
}
|
||||
}
|
||||
}
|
||||
return nodesLen;}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,20 +1,16 @@
|
||||
---
|
||||
id: 587d8257367417b2b2512c7c
|
||||
title: Check if an Element is Present in a Binary Search Tree
|
||||
localeTitle: Compruebe si un elemento está presente en un árbol de búsqueda binario
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Compruebe si un elemento está presente en un árbol de búsqueda binario
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora que tenemos una idea general de lo que es un árbol de búsqueda binario, hablemos de ello con un poco más de detalle. Los árboles de búsqueda binarios proporcionan tiempo logarítmico para las operaciones comunes de búsqueda, inserción y eliminación en el caso promedio, y el tiempo lineal en el peor de los casos. ¿Por qué es esto? Cada una de esas operaciones básicas nos obliga a encontrar un elemento en el árbol (o en el caso de la inserción para encontrar dónde debe ir) y debido a la estructura de árbol en cada nodo principal, estamos bifurcando a la izquierda o la derecha y excluyendo efectivamente la mitad del tamaño del árbol restante. Esto hace que la búsqueda sea proporcional al logaritmo del número de nodos en el árbol, lo que crea el tiempo logarítmico para estas operaciones en el caso promedio.
|
||||
Ok, pero ¿qué pasa con el peor de los casos? Bueno, considere construir un árbol a partir de los siguientes valores, agregándolos de izquierda a derecha: <code>10</code> , <code>12</code> , <code>17</code> , <code>25</code> . Siguiendo nuestras reglas para un árbol de búsqueda binario, agregaremos <code>12</code> a la derecha de <code>10</code> , <code>17</code> a la derecha de este, y <code>25</code> a la derecha de este. Ahora nuestro árbol se asemeja a una lista enlazada y recorrerla para encontrar <code>25</code> requeriría que recorriéramos todos los elementos de manera lineal. Por lo tanto, el tiempo lineal en el peor de los casos. El problema aquí es que el árbol está desequilibrado. Veremos un poco más sobre lo que esto significa en los siguientes desafíos.
|
||||
Instrucciones: En este desafío, crearemos una utilidad para nuestro árbol. Escriba un método <code>isPresent</code> que toma un valor entero como entrada y devuelve un valor booleano para la presencia o ausencia de ese valor en el árbol de búsqueda binario.
|
||||
</section>
|
||||
<section id="description"> Ahora que tenemos una idea general de lo que es un árbol de búsqueda binario, hablemos de ello con un poco más de detalle. Los árboles de búsqueda binarios proporcionan tiempo logarítmico para las operaciones comunes de búsqueda, inserción y eliminación en el caso promedio, y el tiempo lineal en el peor de los casos. ¿Por qué es esto? Cada una de esas operaciones básicas nos obliga a encontrar un elemento en el árbol (o en el caso de la inserción para encontrar dónde debe ir) y debido a la estructura de árbol en cada nodo principal, estamos bifurcando a la izquierda o la derecha y excluyendo efectivamente la mitad del tamaño del árbol restante. Esto hace que la búsqueda sea proporcional al logaritmo del número de nodos en el árbol, lo que crea el tiempo logarítmico para estas operaciones en el caso promedio. Ok, pero ¿qué pasa con el peor de los casos? Bueno, considere construir un árbol a partir de los siguientes valores, agregándolos de izquierda a derecha: <code>10</code> , <code>12</code> , <code>17</code> , <code>25</code> . Siguiendo nuestras reglas para un árbol de búsqueda binario, agregaremos <code>12</code> a la derecha de <code>10</code> , <code>17</code> a la derecha de este, y <code>25</code> a la derecha de este. Ahora nuestro árbol se asemeja a una lista enlazada y recorrerla para encontrar <code>25</code> requeriría que recorriéramos todos los elementos de manera lineal. Por lo tanto, el tiempo lineal en el peor de los casos. El problema aquí es que el árbol está desequilibrado. Veremos un poco más sobre lo que esto significa en los siguientes desafíos. Instrucciones: En este desafío, crearemos una utilidad para nuestro árbol. Escriba un método <code>isPresent</code> que toma un valor entero como entrada y devuelve un valor booleano para la presencia o ausencia de ese valor en el árbol de búsqueda binario. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -52,6 +48,7 @@ function BinarySearchTree() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,30 +1,16 @@
|
||||
---
|
||||
id: 587d8255367417b2b2512c75
|
||||
title: Create a Circular Queue
|
||||
localeTitle: Crear una cola circular
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear una cola circular
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En este desafío estarás creando una Cola Circular. Una cola circular es básicamente una cola que se escribe al final de una colección y luego comienza a escribirse al principio de la colección. Este es un tipo de estructura de datos que tiene algunas aplicaciones útiles en ciertas situaciones. Por ejemplo, una cola circular se puede utilizar para transmitir medios. Una vez que la cola está llena, los nuevos datos de medios simplemente comienzan a sobrescribir los datos antiguos.
|
||||
Una buena manera de ilustrar este concepto es con una matriz:
|
||||
<blockquote>[1, 2, 3, 4, 5]<br> ^Read @ 0<br> ^Write @ 0</blockquote>
|
||||
Aquí tanto la lectura como la escritura están en la posición <code>0</code> . Ahora la cola obtiene 3 nuevos registros <code>a</code> , <code>b</code> , y <code>c</code> . Nuestra cola ahora se ve como:
|
||||
<blockquote>[a, b, c, 4, 5]<br> ^Read @ 0<br> ^Write @ 3</blockquote>
|
||||
Mientras la cabeza de lectura lee, puede eliminar valores o mantenerlos:
|
||||
<blockquote>[null, null, null, 4, 5]<br> ^Read @ 3<br> ^Write @ 3</blockquote>
|
||||
Una vez que la escritura llega al final de la matriz, vuelve al principio:
|
||||
<blockquote>[f, null, null, d, e]<br> ^Read @ 3<br> ^Write @ 1</blockquote>
|
||||
Este enfoque requiere una cantidad constante de memoria, pero permite procesar archivos de un tamaño mucho mayor.
|
||||
Instrucciones:
|
||||
En este desafío implementaremos una cola circular. La cola circular debe proporcionar métodos de <code>dequeue</code> <code>enqueue</code> y <code>dequeue</code> <code>enqueue</code> que le permitan leer y escribir en la cola. La clase en sí también debe aceptar un número entero que puede usar para especificar el tamaño de la cola cuando la cree. Hemos escrito la versión inicial de esta clase para usted en el editor de código. Cuando pone en cola elementos en la cola, el puntero de escritura debe avanzar y volver al principio una vez que llega al final de la cola. Del mismo modo, el puntero de lectura debe avanzar hacia adelante a medida que se retiran de la cola los elementos. No se debe permitir que el puntero de escritura se mueva más allá del puntero de lectura (nuestra clase no le permitirá sobrescribir datos que aún no ha leído) y el puntero de lectura no debe poder avanzar los datos pasados que haya escrito.
|
||||
Además, el método de <code>enqueue</code> debe devolver el elemento que ha puesto en <code>enqueue</code> si tiene éxito y, de lo contrario, devolver el <code>null</code> . De manera similar, cuando saca de la cola un artículo, debe devolverse y, si no puede sacar la cola, debe devolver un <code>null</code> .
|
||||
</section>
|
||||
<section id="description"> En este desafío estarás creando una Cola Circular. Una cola circular es básicamente una cola que se escribe al final de una colección y luego comienza a escribirse al principio de la colección. Este es un tipo de estructura de datos que tiene algunas aplicaciones útiles en ciertas situaciones. Por ejemplo, una cola circular se puede utilizar para transmitir medios. Una vez que la cola está llena, los nuevos datos de medios simplemente comienzan a sobrescribir los datos antiguos. Una buena manera de ilustrar este concepto es con una matriz: <blockquote> [1, 2, 3, 4, 5] <br> ^ Leer @ 0 <br> ^ Escribe @ 0 </blockquote> Aquí la lectura y la escritura están en la posición <code>0</code> . Ahora la cola obtiene 3 nuevos registros <code>a</code> , <code>b</code> , y <code>c</code> . Nuestra cola ahora se ve como: <blockquote> [a, b, c, 4, 5] <br> ^ Leer @ 0 <br> ^ Escribe @ 3 </blockquote> A medida que lee el cabezal de lectura, puede eliminar valores o mantenerlos: <blockquote> [nulo, nulo, nulo, 4, 5] <br> ^ Leer @ 3 <br> ^ Escribe @ 3 </blockquote> Una vez que la escritura llega al final de la matriz, vuelve al principio: <blockquote> [f, nulo, nulo, d, e] <br> ^ Leer @ 3 <br> ^ Escribe @ 1 </blockquote> Este enfoque requiere una cantidad constante de memoria, pero permite procesar archivos de un tamaño mucho mayor. Instrucciones: En este desafío implementaremos una cola circular. La cola circular debe proporcionar métodos de <code>dequeue</code> <code>enqueue</code> y <code>dequeue</code> <code>enqueue</code> que le permitan leer y escribir en la cola. La clase en sí también debe aceptar un número entero que puede usar para especificar el tamaño de la cola cuando la cree. Hemos escrito la versión inicial de esta clase para usted en el editor de código. Cuando pone en cola elementos en la cola, el puntero de escritura debe avanzar y volver al principio una vez que llega al final de la cola. Del mismo modo, el puntero de lectura debe avanzar hacia adelante a medida que se retiran de la cola los elementos. No se debe permitir que el puntero de escritura se mueva más allá del puntero de lectura (nuestra clase no le permitirá sobrescribir datos que aún no ha leído) y el puntero de lectura no debe poder avanzar los datos pasados que haya escrito. Además, el método de <code>enqueue</code> debe devolver el elemento que ha puesto en <code>enqueue</code> si tiene éxito y, de lo contrario, devolver el <code>null</code> . De manera similar, cuando saca de la cola un artículo, debe devolverse y, si no puede sacar la cola, debe devolver un <code>null</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -38,7 +24,7 @@ tests:
|
||||
testString: 'assert((function(){ var test = new CircularQueue(3); test.enqueue(17); test.enqueue(32); test.enqueue(591); test.enqueue(13); test.enqueue(25); test.enqueue(59); var print = test.print(); return print[0] === 17 && print[1] === 32 && print[2] === 591; })(), "You cannot enqueue items past the read pointer.");'
|
||||
- text: La <code>dequeue</code> método de Retiros de cola elementos de la cola.
|
||||
testString: 'assert((function(){ var test = new CircularQueue(3); test.enqueue(17); test.enqueue(32); test.enqueue(591); return test.dequeue() === 17 && test.dequeue() === 32 && test.dequeue() === 591; })(), "The <code>dequeue</code> method dequeues items from the queue.");'
|
||||
- text: Después de que un elemento se haya retirado de su posición en la cola, se debe restablecer en <code>null</code> .
|
||||
- text: 'Después de que un elemento se haya retirado de su posición en la cola, se debe restablecer en <code>null</code> .'
|
||||
testString: 'assert((function(){ var test = new CircularQueue(3); test.enqueue(17); test.enqueue(32); test.enqueue(672); test.dequeue(); test.dequeue(); var print = test.print(); return print[0] === null && print[1] === null && print[2] === 672; })(), "After an item is dequeued its position in the queue should be reset to <code>null</code>.");'
|
||||
- text: Intentar sacar de la cola más allá del puntero de escritura devuelve un <code>null</code> y no avanza el puntero de escritura.
|
||||
testString: 'assert((function(){ var test = new CircularQueue(3); test.enqueue(17); test.enqueue(32); test.enqueue(591); return test.dequeue() === 17 && test.dequeue() === 32 && test.dequeue() === 591 && test.dequeue() === null && test.dequeue() === null && test.dequeue() === null && test.dequeue() === null && test.enqueue(100) === 100 && test.dequeue() === 100; })(), "Trying to dequeue past the write pointer returns <code>null</code> and does not advance the write pointer.");'
|
||||
@ -85,6 +71,7 @@ class CircularQueue {
|
||||
// Only change code above this line
|
||||
}
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -96,49 +83,7 @@ class CircularQueue {
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
class CircularQueue {
|
||||
constructor(size) {
|
||||
this.queue = [];
|
||||
this.read = 0;
|
||||
this.write = 0;
|
||||
this.max = size - 1;
|
||||
while (size > 0) {
|
||||
this.queue.push(null);
|
||||
size--;
|
||||
}
|
||||
}
|
||||
print() {
|
||||
return this.queue;
|
||||
}
|
||||
enqueue(item) {
|
||||
if (this.queue[this.write] === null) {
|
||||
this.queue[this.write] = item;
|
||||
if (this.write === this.max) {
|
||||
this.write = 0;
|
||||
} else {
|
||||
this.write++;
|
||||
}
|
||||
return item;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
dequeue() {
|
||||
if (this.queue[this.read] !== null) {
|
||||
var item = this.queue[this.read];
|
||||
this.queue[this.read] = null;
|
||||
if (this.read === this.max) {
|
||||
this.read = 0;
|
||||
} else {
|
||||
this.read++;
|
||||
}
|
||||
return item;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 587d825a367417b2b2512c87
|
||||
title: Create a Doubly Linked List
|
||||
localeTitle: Crear una lista doblemente vinculada
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear una lista doblemente vinculada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Todas las listas enlazadas que hemos creado hasta ahora son listas enlazadas individualmente. Aquí, crearemos una <dfn>lista doblemente vinculada</dfn> . Como su nombre lo indica, los nodos en una lista doblemente enlazada tienen referencias al nodo siguiente y anterior en la lista.
|
||||
Esto nos permite recorrer la lista en ambas direcciones, pero también requiere que se use más memoria porque cada nodo debe contener una referencia adicional al nodo anterior en la lista.
|
||||
</section>
|
||||
<section id="description"> Todas las listas enlazadas que hemos creado hasta ahora son listas enlazadas individualmente. Aquí, crearemos una <dfn>lista doblemente vinculada</dfn> . Como su nombre lo indica, los nodos en una lista doblemente enlazada tienen referencias al nodo siguiente y anterior en la lista. Esto nos permite recorrer la lista en ambas direcciones, pero también requiere que se use más memoria porque cada nodo debe contener una referencia adicional al nodo anterior en la lista. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Proporcionamos un objeto <code>Node</code> y comenzamos nuestra <code>DoublyLinkedList</code> . Agreguemos dos métodos a nuestra lista doblemente enlazada llamada <code>add</code> y <code>remove</code> . El <code>add</code> método debe añadir el elemento dado de la lista, mientras que el <code>remove</code> método debe eliminar todas las ocurrencias de un elemento dado en la lista.
|
||||
Tenga cuidado de manejar cualquier posible caso de borde al escribir estos métodos, como eliminaciones del primer o último elemento. Además, eliminar cualquier elemento de una lista vacía debe devolver <code>null</code> .
|
||||
</section>
|
||||
<section id="instructions"> Proporcionamos un objeto <code>Node</code> y comenzamos nuestra <code>DoublyLinkedList</code> . Agreguemos dos métodos a nuestra lista doblemente enlazada llamada <code>add</code> y <code>remove</code> . El <code>add</code> método debe añadir el elemento dado de la lista, mientras que el <code>remove</code> método debe eliminar todas las ocurrencias de un elemento dado en la lista. Tenga cuidado al manejar cualquier posible caso de borde al escribir estos métodos, como eliminaciones del primer o último elemento. Además, eliminar cualquier elemento de una lista vacía debe devolver <code>null</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@ -28,7 +23,7 @@ tests:
|
||||
testString: 'assert((function() { var test = false; if (typeof DoublyLinkedList !== "undefined") { test = new DoublyLinkedList() }; if (test.add == undefined) { return false; }; return (typeof test.add == "function")})(), "The DoublyLinkedList has a method called add.");'
|
||||
- text: DoublyLinkedList tiene un método llamado eliminar.
|
||||
testString: 'assert((function() { var test = false; if (typeof DoublyLinkedList !== "undefined") { test = new DoublyLinkedList() }; if (test.remove == undefined) { return false; }; return (typeof test.remove == "function")})(), "The DoublyLinkedList has a method called remove.");'
|
||||
- text: Al eliminar un elemento de una lista vacía, se devuelve un valor nulo.
|
||||
- text: 'Al eliminar un elemento de una lista vacía, se devuelve un valor nulo.'
|
||||
testString: 'assert((function() { var test = false; if (typeof DoublyLinkedList !== "undefined") { test = new DoublyLinkedList() }; return (test.remove(100) == null); })(), "Removing an item from an empty list returns null.");'
|
||||
- text: El método add agrega elementos a la lista.
|
||||
testString: 'assert((function() { var test = false; if (typeof DoublyLinkedList !== "undefined") { test = new DoublyLinkedList() }; test.add(5); test.add(6); test.add(723); return (test.print().join("") == "56723"); })(), "The add method adds items to the list.");'
|
||||
@ -60,6 +55,7 @@ var DoublyLinkedList = function() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 587d825b367417b2b2512c8e
|
||||
title: Create a Hash Table
|
||||
localeTitle: Crear una tabla de hash
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear una tabla de hash
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En este desafío aprenderemos sobre tablas hash. Se utiliza una tabla Hash para implementar matrices asociativas, o asignaciones de pares clave-valor, como los objetos y los mapas que acabamos de estudiar. Un objeto JavaScript podría implementarse como una tabla hash, por ejemplo (su implementación real dependerá del entorno en el que se esté ejecutando). La forma en que funciona una tabla hash es que toma una entrada clave y hace un hash de esta clave de manera determinista a algún valor numérico. Este valor numérico se utiliza como la clave real por la que se almacena el valor asociado. Luego, si intenta acceder a la misma clave nuevamente, la función de hashing procesará la clave y devolverá el mismo resultado numérico, que luego se usará para buscar el valor asociado. Esto proporciona un tiempo de búsqueda O (n) muy eficiente en promedio.
|
||||
Las tablas hash se pueden implementar como matrices con funciones hash que producen índices de matriz dentro de un rango específico. En este método, la elección del tamaño del arreglo es importante, como lo es la función de hashing. Por ejemplo, ¿qué pasa si la función de hashing produce el mismo valor para dos claves diferentes? Esto se llama una colisión. Una forma de manejar las colisiones es simplemente almacenar ambos pares clave-valor en ese índice. Luego, al buscar cualquiera de los dos, tendría que recorrer el conjunto de elementos para encontrar la clave que está buscando. Una buena función de hash minimizará las colisiones para mantener un tiempo de búsqueda eficiente.
|
||||
Aquí, no nos preocuparemos por los detalles de hashing o la implementación de tablas hash, solo intentaremos tener una idea general de cómo funcionan.
|
||||
Instrucciones: Vamos a crear la funcionalidad básica de una tabla hash. Hemos creado una función de hash ingenua para que la uses. Puede pasar un valor de cadena al hash de función y devolverá un valor hash que puede usar como clave para el almacenamiento. Almacene artículos basados en este valor hash en el objeto this.collection. Crea estos tres métodos: agregar, eliminar y buscar. El primero debe aceptar un par de valores clave para agregar a la tabla hash. El segundo debe eliminar un par clave-valor cuando se pasa una clave. El tercero debe aceptar una clave y devolver el valor asociado o nulo si la clave no está presente.
|
||||
Asegúrese de escribir su código para tener en cuenta las colisiones!
|
||||
</section>
|
||||
<section id="description"> En este desafío aprenderemos sobre tablas hash. Se utiliza una tabla Hash para implementar matrices asociativas, o asignaciones de pares clave-valor, como los objetos y los mapas que acabamos de estudiar. Un objeto JavaScript podría implementarse como una tabla hash, por ejemplo (su implementación real dependerá del entorno en el que se esté ejecutando). La forma en que funciona una tabla hash es que toma una entrada clave y hace un hash de esta clave de manera determinista a algún valor numérico. Este valor numérico se utiliza como la clave real por la que se almacena el valor asociado. Luego, si intenta acceder a la misma clave nuevamente, la función de hashing procesará la clave y devolverá el mismo resultado numérico, que luego se usará para buscar el valor asociado. Esto proporciona un tiempo de búsqueda O (n) muy eficiente en promedio. Las tablas hash se pueden implementar como matrices con funciones hash que producen índices de matriz dentro de un rango específico. En este método, la elección del tamaño del arreglo es importante, como lo es la función de hashing. Por ejemplo, ¿qué pasa si la función de hashing produce el mismo valor para dos claves diferentes? Esto se llama una colisión. Una forma de manejar las colisiones es simplemente almacenar ambos pares clave-valor en ese índice. Luego, al buscar cualquiera de los dos, tendría que recorrer el conjunto de elementos para encontrar la clave que está buscando. Una buena función de hash minimizará las colisiones para mantener un tiempo de búsqueda eficiente. En este caso, no nos preocuparemos por los detalles de hashing o la implementación de tablas hash, solo intentaremos obtener una idea general de cómo funcionan. Instrucciones: Vamos a crear la funcionalidad básica de una tabla hash. Hemos creado una función de hash ingenua para que la uses. Puede pasar un valor de cadena al hash de función y devolverá un valor hash que puede usar como clave para el almacenamiento. Almacene artículos basados en este valor hash en el objeto this.collection. Crea estos tres métodos: agregar, eliminar y buscar. El primero debe aceptar un par de valores clave para agregar a la tabla hash. El segundo debe eliminar un par clave-valor cuando se pasa una clave. El tercero debe aceptar una clave y devolver el valor asociado o nulo si la clave no está presente. ¡Asegúrese de escribir su código para tener en cuenta las colisiones! </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -63,6 +57,7 @@ var HashTable = function() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -78,6 +73,7 @@ var HashTable = function() {
|
||||
for (var i = 0; i < string.length; i++) { hash += string.charCodeAt(i); };
|
||||
return hash;
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 587d8251367417b2b2512c62
|
||||
title: Create a Linked List Class
|
||||
localeTitle: Crear una clase de lista enlazada
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear una clase de lista enlazada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Vamos a crear una clase de <code>linked list</code> . Cada lista vinculada debe comenzar con unas pocas propiedades básicas: una <code>head</code> (el primer elemento de su lista) y una <code>length</code> (número de elementos en su lista). A veces, verás implementaciones de listas vinculadas que incorporan una <code>tail</code> para el último elemento de la lista, pero por ahora solo nos quedaremos con estos dos. Cada vez que agregamos un elemento a la lista vinculada, nuestra propiedad de <code>length</code> debe incrementarse en uno.
|
||||
Queremos tener una forma de agregar elementos a nuestra lista vinculada, por lo que el primer método que querremos crear es el método de <code>add</code> .
|
||||
Si nuestra lista está vacía, agregar un elemento a nuestra lista vinculada es lo suficientemente simple: simplemente envolvemos ese elemento en una clase de <code>Node</code> , y asignamos ese nodo al <code>head</code> de nuestra lista vinculada.
|
||||
¿Pero qué pasa si nuestra lista ya tiene uno o más miembros? ¿Cómo agregamos un elemento a la lista? Recuerde que cada nodo en una lista vinculada tiene una propiedad <code>next</code> . Para agregar un nodo a la lista, busque el último nodo en la lista y apunte la <code>next</code> propiedad del último nodo a nuestro nuevo nodo. (Sugerencia: sabe que ha llegado al final de una lista enlazada cuando la <code>next</code> propiedad de un nodo es <code>null</code> ).
|
||||
</section>
|
||||
<section id="description"> Vamos a crear una clase de <code>linked list</code> . Cada lista vinculada debe comenzar con unas pocas propiedades básicas: una <code>head</code> (el primer elemento de su lista) y una <code>length</code> (número de elementos en su lista). A veces, verás implementaciones de listas vinculadas que incorporan una <code>tail</code> para el último elemento de la lista, pero por ahora solo nos quedaremos con estos dos. Cada vez que agregamos un elemento a la lista vinculada, nuestra propiedad de <code>length</code> debe incrementarse en uno. Queremos tener una forma de agregar elementos a nuestra lista vinculada, por lo que el primer método que querremos crear es el método de <code>add</code> . Si nuestra lista está vacía, agregar un elemento a nuestra lista vinculada es lo suficientemente simple: simplemente envolvemos ese elemento en una clase de <code>Node</code> , y asignamos ese nodo al <code>head</code> de nuestra lista vinculada. Pero, ¿y si nuestra lista ya tiene uno o más miembros? ¿Cómo agregamos un elemento a la lista? Recuerde que cada nodo en una lista vinculada tiene una propiedad <code>next</code> . Para agregar un nodo a la lista, busque el último nodo en la lista y apunte la <code>next</code> propiedad del último nodo a nuestro nuevo nodo. (Sugerencia: sabe que ha llegado al final de una lista vinculada cuando la <code>next</code> propiedad de un nodo es <code>null</code> ). </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Escriba un método de adición que asigne el primer nodo que empuja a la lista vinculada al <code>head</code> ; después de eso, cada vez que agregue un nodo, cada nodo debe ser referenciado por la <code>next</code> propiedad del nodo anterior.
|
||||
Nota
|
||||
La <code>length</code> su lista debe aumentar en uno cada vez que se agregue un elemento a la lista vinculada.
|
||||
</section>
|
||||
<section id="instructions"> Escriba un método de adición que asigne el primer nodo que empuja a la lista vinculada al <code>head</code> ; después de eso, cada vez que agregue un nodo, cada nodo debe ser referenciado por la <code>next</code> propiedad del nodo anterior. Nota La <code>length</code> su lista debe aumentar en uno cada vez que se agregue un elemento a la lista vinculada. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@ -67,6 +59,7 @@ function LinkedList() {
|
||||
// Only change code above this line
|
||||
};
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,29 +1,16 @@
|
||||
---
|
||||
id: 8d5823c8c441eddfaeb5bdef
|
||||
title: Create a Map Data Structure
|
||||
localeTitle: Crear una estructura de datos de mapas
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear una estructura de datos de mapas
|
||||
---
|
||||
|
||||
## 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>
|
||||
<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 Map: <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>
|
||||
|
||||
## Tests
|
||||
@ -61,6 +48,7 @@ var Map = function() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 587d8255367417b2b2512c74
|
||||
title: Create a Priority Queue Class
|
||||
localeTitle: Crear una clase de cola de prioridad
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear una clase de cola de prioridad
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En este desafío crearás una cola de prioridad. Una cola de prioridad es un tipo especial de cola en la que los elementos pueden tener información adicional que especifica su prioridad. Esto podría ser representado simplemente con un número entero. La prioridad de los elementos anulará el orden de colocación para determinar si los elementos de la secuencia se eliminan. Si un elemento con una prioridad más alta se pone en cola después de los elementos con una prioridad más baja, el elemento de mayor prioridad se eliminará de la cola antes que todos los demás.
|
||||
Por ejemplo, imaginemos que tenemos una cola de prioridad con tres elementos:
|
||||
<code>[['kitten', 2], ['dog', 2], ['rabbit', 2]]</code>
|
||||
Aquí el segundo valor (un entero) representa la prioridad del elemento. Si ponemos en cola <code>['human', 1]</code> con una prioridad de <code>1</code> (suponiendo que se da prioridad a las prioridades más bajas) sería el primer elemento que se eliminará de la cola. A la colección le gustaría esto:
|
||||
<code>[['human', 1], ['kitten', 2], ['dog', 2], ['rabbit', 2]]</code> .
|
||||
Hemos empezado a escribir un <code>PriorityQueue</code> en el editor de código. Necesitará agregar un método de <code>enqueue</code> en <code>enqueue</code> para agregar elementos con una prioridad, un método de <code>dequeue</code> para eliminar elementos, un método de <code>size</code> para devolver el número de elementos en la cola, un método <code>front</code> para devolver el elemento al frente de la cola y finalmente, un método <code>isEmpty</code> que devolverá <code>true</code> si la cola está vacía o <code>false</code> si no lo está.
|
||||
La <code>enqueue</code> debe aceptar elementos con el formato que se muestra arriba ( <code>['human', 1]</code> ) donde <code>1</code> representa la prioridad. La <code>dequeue</code> debe devolver solo el elemento actual, no su prioridad.
|
||||
</section>
|
||||
<section id="description"> En este desafío crearás una cola de prioridad. Una cola de prioridad es un tipo especial de cola en la que los elementos pueden tener información adicional que especifica su prioridad. Esto podría ser representado simplemente con un número entero. La prioridad de los elementos anulará el orden de colocación para determinar si los elementos de la secuencia se eliminan. Si un elemento con una prioridad más alta se pone en cola después de los elementos con una prioridad más baja, el elemento de mayor prioridad se eliminará de la cola antes que todos los demás. Por ejemplo, imaginemos que tenemos una cola de prioridad con tres elementos: <code>[['kitten', 2], ['dog', 2], ['rabbit', 2]]</code> Aquí el segundo valor (un entero) representa la prioridad del elemento . Si ponemos en cola <code>['human', 1]</code> con una prioridad de <code>1</code> (suponiendo que se da prioridad a las prioridades más bajas) sería el primer elemento que se eliminará de la cola. A la colección le gustaría esto: <code>[['human', 1], ['kitten', 2], ['dog', 2], ['rabbit', 2]]</code> . Empezamos a escribir un <code>PriorityQueue</code> en el editor de código. Necesitará agregar un método de <code>enqueue</code> en <code>enqueue</code> para agregar elementos con una prioridad, un método de <code>dequeue</code> para eliminar elementos, un método de <code>size</code> para devolver el número de elementos en la cola, un método <code>front</code> para devolver el elemento al frente de la cola y finalmente, un método <code>isEmpty</code> que devolverá <code>true</code> si la cola está vacía o <code>false</code> si no lo está. La <code>enqueue</code> debe aceptar elementos con el formato que se muestra arriba ( <code>['human', 1]</code> ) donde <code>1</code> representa la prioridad. La <code>dequeue</code> debe devolver solo el elemento actual, no su prioridad. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -34,11 +26,11 @@ tests:
|
||||
testString: 'assert((function(){var test = new PriorityQueue(); return (typeof test.size === "function")}()), "Your <code>Queue</code> class should have a <code>size</code> method.");'
|
||||
- text: Tu clase de <code>Queue</code> debe tener un método <code>isEmpty</code> .
|
||||
testString: 'assert((function(){var test = new PriorityQueue(); return (typeof test.isEmpty === "function")}()), "Your <code>Queue</code> class should have an <code>isEmpty</code> method.");'
|
||||
- text: Su PriorityQueue debe realizar un seguimiento correcto del número actual de elementos utilizando el método de <code>size</code> , ya que los elementos se ponen en cola y se eliminan de la cola.
|
||||
- text: 'Su PriorityQueue debe realizar un seguimiento correcto del número actual de elementos utilizando el método de <code>size</code> , ya que los elementos se ponen en cola y se eliminan de la cola.'
|
||||
testString: 'assert((function(){var test = new PriorityQueue(); test.enqueue(["David Brown", 2]); test.enqueue(["Jon Snow", 1]); var size1 = test.size(); test.dequeue(); var size2 = test.size(); test.enqueue(["A", 3]); test.enqueue(["B", 3]); test.enqueue(["C", 3]); return (size1 === 2 && size2 === 1 && test.size() === 4)}()), "Your PriorityQueue should correctly keep track of the current number of items using the <code>size</code> method as items are enqueued and dequeued.");'
|
||||
- text: El método <code>isEmpty</code> debería devolver <code>true</code> cuando la cola está vacía.
|
||||
testString: 'assert((function(){var test = new PriorityQueue(); test.enqueue(["A", 1]); test.enqueue(["B", 1]); test.dequeue(); var first = test.isEmpty(); test.dequeue(); return (!first && test.isEmpty()); }()), "The <code>isEmpty</code> method should return <code>true</code> when the queue is empty.");'
|
||||
- text: La cola de prioridad debe devolver los elementos con una prioridad más alta antes de los elementos con una prioridad más baja y devolver los elementos en el orden de primero en entrar, primero en salir, de lo contrario
|
||||
- text: 'La cola de prioridad debe devolver los elementos con una prioridad más alta antes de los elementos con una prioridad más baja y devolver los elementos en el orden de primero en entrar, primero en salir, de lo contrario.'
|
||||
testString: 'assert((function(){var test = new PriorityQueue(); test.enqueue(["A", 5]); test.enqueue(["B", 5]); test.enqueue(["C", 5]); test.enqueue(["D", 3]); test.enqueue(["E", 1]); test.enqueue(["F", 7]); var result = []; result.push(test.dequeue()); result.push(test.dequeue()); result.push(test.dequeue()); result.push(test.dequeue()); result.push(test.dequeue()); result.push(test.dequeue()); return result.join("") === "EDABCF";}()), "The priority queue should return items with a higher priority before items with a lower priority and return items in first-in-first-out order otherwise.");'
|
||||
|
||||
```
|
||||
@ -60,6 +52,7 @@ function PriorityQueue () {
|
||||
|
||||
// Only change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -71,43 +64,7 @@ function PriorityQueue () {
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function PriorityQueue () {
|
||||
this.collection = [];
|
||||
this.printCollection = function(){
|
||||
console.log(this.collection);
|
||||
};
|
||||
this.size = function() {
|
||||
return this.collection.length;
|
||||
};
|
||||
this.isEmpty = function() {
|
||||
return this.size() > 0 ? false : true;
|
||||
};
|
||||
this.enqueue = function (newitem) {
|
||||
if (this.isEmpty()) {
|
||||
return this.collection.push(newitem);
|
||||
}
|
||||
|
||||
this.collection = this.collection.reverse();
|
||||
var found_index = this.collection.findIndex(function (item) {
|
||||
return newitem[1] >= item[1];
|
||||
});
|
||||
if (found_index === -1) {
|
||||
this.collection.push(newitem);
|
||||
} else {
|
||||
this.collection.splice(found_index, 0, newitem);
|
||||
}
|
||||
this.collection = this.collection.reverse();
|
||||
};
|
||||
this.dequeue = function() {
|
||||
if (!this.isEmpty()) {
|
||||
return this.collection.shift()[0];
|
||||
} else {
|
||||
return 'The queue is empty.'
|
||||
}
|
||||
};
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 587d8250367417b2b2512c60
|
||||
title: Create a Queue Class
|
||||
localeTitle: Crear una clase de cola
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear una clase de cola
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Al igual que las pilas, las colas son una colección de elementos. Pero a diferencia de las pilas, las colas siguen el principio FIFO (primero en entrar, primero en salir). Los elementos agregados a una cola se empujan a la cola, o al final, de la cola, y solo se permite eliminar el elemento en la parte delantera de la cola.
|
||||
Podríamos usar una matriz para representar una cola, pero al igual que las pilas, queremos limitar la cantidad de control que tenemos sobre nuestras colas.
|
||||
Los dos métodos principales de una clase de cola son la puesta en cola y el método de salida. El método de puesta en cola empuja un elemento a la cola de la cola, y el método de salida de cola elimina y devuelve el elemento al frente de la cola. Otros métodos útiles son los métodos de frente, tamaño e isEmpty.
|
||||
Instrucciones
|
||||
Escriba un método de puesta en cola que empuja un elemento a la cola de la cola, un método de salida de cola que elimina y devuelve el elemento frontal, un método frontal que nos permite ver el elemento frontal, un método de tamaño que muestra la longitud y una Método isEmpty para verificar si la cola está vacía.
|
||||
</section>
|
||||
<section id="description"> Al igual que las pilas, las colas son una colección de elementos. Pero a diferencia de las pilas, las colas siguen el principio FIFO (primero en entrar, primero en salir). Los elementos agregados a una cola se empujan a la cola, o al final, de la cola, y solo se permite eliminar el elemento en la parte delantera de la cola. Podríamos usar una matriz para representar una cola, pero al igual que las pilas, queremos limitar la cantidad de control que tenemos sobre nuestras colas. Los dos métodos principales de una clase de cola son la puesta en cola y el método de salida. El método de puesta en cola empuja un elemento a la cola de la cola, y el método de salida de cola elimina y devuelve el elemento en la parte delantera de la cola. Otros métodos útiles son los métodos de frente, tamaño e isEmpty. Instrucciones Escriba un método de puesta en cola que empuja un elemento a la cola de la cola, un método de salida de cola que elimina y devuelve el elemento frontal, un método frontal que nos permite ver el elemento frontal, un método de tamaño que muestra la longitud y un método isEmpty para comprobar si la cola está vacía. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -62,6 +56,7 @@ function Queue () {
|
||||
|
||||
// Only change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 8d1323c8c441eddfaeb5bdef
|
||||
title: Create a Set Class
|
||||
localeTitle: Crear una clase de conjunto
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear una clase de conjunto
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En los próximos ejercicios, vamos a crear una función para emular una estructura de datos llamada "Conjunto". Un conjunto es como una matriz, pero no puede contener valores duplicados. El uso típico de un Conjunto es simplemente verificar la presencia de un elemento. Esto se puede implementar con un objeto, por ejemplo:
|
||||
<blockquote>var set = new Object();<br>set.foo = true;<br>// See if foo exists in our set:<br>console.log(set.foo) // true</blockquote>
|
||||
En los próximos ejercicios, construiremos un conjunto completo desde cero.
|
||||
Para este ejercicio, cree una función que agregue un valor a nuestra colección de conjuntos siempre que el valor no exista en el conjunto. Por ejemplo:
|
||||
<blockquote>this.add = function(element) {<br> //some code to add value to the set<br>}</blockquote>
|
||||
La función debe devolver <code>true</code> si el valor se agrega exitosamente y <code>false</code> contrario.
|
||||
</section>
|
||||
<section id="description"> En los siguientes ejercicios vamos a crear una función para emular una estructura de datos llamada "Conjunto". Un conjunto es como una matriz, pero no puede contener valores duplicados. El uso típico de un Conjunto es simplemente verificar la presencia de un elemento. Esto se puede implementar con un objeto, por ejemplo: <blockquote> var set = new Object (); <br> set.foo = true; <br> // Ver si existe foo en nuestro set: <br> console.log (set.foo) // true </blockquote> En los próximos ejercicios, construiremos un conjunto completo desde cero. Para este ejercicio, cree una función que agregue un valor a nuestra colección de conjuntos siempre que el valor no exista en el conjunto. Por ejemplo: <blockquote> this.add = function (element) { <br> // algún código para agregar valor al conjunto <br> } </blockquote> La función debe devolver <code>true</code> si el valor se agrega exitosamente y <code>false</code> contrario. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -58,6 +51,7 @@ function Set() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -69,9 +63,7 @@ function Set() {
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function Set() {var collection = []; this.has = function(e){return(collection.indexOf(e) !== -1);};this.values = function() {return collection;};this.add = function(element) {if (!this.has(element)) {collection.push(element);return true;} else {return false;}};}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 587d8250367417b2b2512c5f
|
||||
title: Create a Stack Class
|
||||
localeTitle: Crear una clase de pila
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear una clase de pila
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En la sección anterior, hablamos sobre qué es una pila y cómo podemos usar una matriz para representar una pila. En esta sección, crearemos nuestra propia clase de pila.
|
||||
Aunque puede usar matrices para crear pilas, a veces es mejor limitar la cantidad de control que tenemos con nuestras pilas.
|
||||
Aparte del método <code>push</code> y <code>pop</code> , las pilas tienen otros métodos útiles. <code>isEmpty</code> <code>clear</code> método <code>peek</code> , <code>isEmpty</code> y <code>clear</code> a nuestra clase de pila.
|
||||
Instrucciones
|
||||
Escribe un método de <code>push</code> que empuja un elemento a la parte superior de la pila, un método <code>pop</code> que elimina el elemento de la parte superior de la pila, un método de <code>peek</code> que mira el primer elemento de la pila, un método <code>isEmpty</code> que verifica si la pila está vacía, y un método <code>clear</code> que elimina todos los elementos de la pila.
|
||||
Normalmente las pilas no tienen esto, pero hemos agregado un método de ayuda de <code>print</code> que la consola registra la colección.
|
||||
</section>
|
||||
<section id="description"> En la sección anterior, hablamos sobre qué es una pila y cómo podemos usar una matriz para representar una pila. En esta sección, crearemos nuestra propia clase de pila. Aunque puede utilizar matrices para crear pilas, a veces es mejor limitar la cantidad de control que tenemos con nuestras pilas. Aparte del método <code>push</code> y <code>pop</code> , las pilas tienen otros métodos útiles. <code>isEmpty</code> <code>clear</code> método <code>peek</code> , <code>isEmpty</code> y <code>clear</code> a nuestra clase de pila. Instrucciones Escriba un método de <code>push</code> que empuja un elemento a la parte superior de la pila, un método <code>pop</code> que elimina el elemento de la parte superior de la pila, un método de <code>peek</code> que mira el primer elemento de la pila, un método <code>isEmpty</code> que verifica si la pila está vacía, y un método <code>clear</code> que elimina todos los elementos de la pila. Normalmente las pilas no tienen esto, pero hemos agregado un método de ayuda de <code>print</code> que la consola registra la colección. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -63,6 +56,7 @@ function Stack() {
|
||||
|
||||
// Only change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 587d8259367417b2b2512c84
|
||||
title: Create a Trie Search Tree
|
||||
localeTitle: Crear un árbol de búsqueda Trie
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear un árbol de búsqueda Trie
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Aquí pasaremos de los árboles de búsqueda binarios y echaremos un vistazo a otro tipo de estructura de árbol llamada trie. Un trie es un árbol de búsqueda ordenada que se usa comúnmente para contener cadenas, o matrices asociativas más genéricamente o conjuntos de datos dinámicos en los que las claves son cadenas. Son muy buenos para almacenar conjuntos de datos cuando muchas claves tienen prefijos que se superponen, por ejemplo, todas las palabras en un diccionario.
|
||||
A diferencia de un árbol binario, los nodos no están asociados con valores reales. En su lugar, la ruta a un nodo representa una clave específica. Por ejemplo, si quisiéramos almacenar el código de cadena en un trío, tendríamos cuatro nodos, uno para cada letra: c - o - d - e. Seguir esa ruta a través de todos estos nodos creará un código como una cadena, esa es la clave que almacenamos. Luego, si quisiéramos agregar la codificación de cadena, compartiría los primeros tres nodos de código antes de bifurcarse después de la d. De esta manera, los grandes conjuntos de datos se pueden almacenar de forma muy compacta. Además, la búsqueda puede ser muy rápida porque se limita efectivamente a la longitud de la cadena que está almacenando. Además, a diferencia de los árboles binarios, un nodo puede almacenar cualquier número de nodos secundarios.
|
||||
Como puede haber adivinado en el ejemplo anterior, algunos metadatos se almacenan comúnmente en los nodos que contienen el final de una clave, de modo que en los recorridos posteriores se puede recuperar esa clave. Por ejemplo, si agregamos códigos en nuestro ejemplo anterior, necesitaríamos alguna forma de saber que la e en el código representa el final de una clave que se ingresó anteriormente. De lo contrario, esta información se perdería efectivamente al agregar códigos.
|
||||
Instrucciones: Vamos a crear un trie para almacenar palabras. Aceptará palabras a través de un método de adición y las almacenará en una estructura de datos trie. También nos permitirá consultar si una cadena dada es una palabra con un método isWord, y recuperar todas las palabras ingresadas en el texto con un método de impresión. isWord debería devolver un valor booleano e imprimir debería devolver una matriz de todas estas palabras como valores de cadena.
|
||||
Para que podamos verificar que esta estructura de datos se implementa correctamente, proporcionamos una estructura de Nodo para cada nodo en el árbol. Cada nodo será un objeto con una propiedad de claves que es un objeto de mapa de JavaScript. Esto mantendrá las letras individuales que son claves válidas de cada nodo. También hemos creado una propiedad final en los nodos que se pueden establecer en verdadero si el nodo representa la terminación de una palabra.
|
||||
</section>
|
||||
<section id="description"> Aquí pasaremos de los árboles de búsqueda binarios y echaremos un vistazo a otro tipo de estructura de árbol llamada trie. Un trie es un árbol de búsqueda ordenada que se usa comúnmente para contener cadenas, o matrices asociativas más genéricamente o conjuntos de datos dinámicos en los que las claves son cadenas. Son muy buenos para almacenar conjuntos de datos cuando muchas claves tienen prefijos que se superponen, por ejemplo, todas las palabras en un diccionario. A diferencia de un árbol binario, los nodos no están asociados con valores reales. En su lugar, la ruta a un nodo representa una clave específica. Por ejemplo, si quisiéramos almacenar el código de cadena en un trío, tendríamos cuatro nodos, uno para cada letra: c - o - d - e. Seguir esa ruta a través de todos estos nodos creará un código como una cadena, esa es la clave que almacenamos. Luego, si quisiéramos agregar la codificación de cadena, compartiría los primeros tres nodos de código antes de bifurcarse después de la d. De esta manera, los grandes conjuntos de datos se pueden almacenar de forma muy compacta. Además, la búsqueda puede ser muy rápida porque se limita efectivamente a la longitud de la cadena que está almacenando. Además, a diferencia de los árboles binarios, un nodo puede almacenar cualquier número de nodos secundarios. Como puede haber adivinado en el ejemplo anterior, algunos metadatos se almacenan comúnmente en los nodos que contienen el final de una clave, de modo que en los recorridos posteriores esa clave aún puede recuperarse. Por ejemplo, si agregamos códigos en nuestro ejemplo anterior, necesitaríamos alguna forma de saber que la e en el código representa el final de una clave que se ingresó anteriormente. De lo contrario, esta información se perdería efectivamente al agregar códigos. Instrucciones: Vamos a crear un trie para almacenar palabras. Aceptará palabras a través de un método de adición y las almacenará en una estructura de datos trie. También nos permitirá consultar si una cadena dada es una palabra con un método isWord, y recuperar todas las palabras ingresadas en el texto con un método de impresión. isWord debería devolver un valor booleano e imprimir debería devolver una matriz de todas estas palabras como valores de cadena. Para que podamos verificar que esta estructura de datos está implementada correctamente, hemos proporcionado una estructura de Nodo para cada nodo en el árbol. Cada nodo será un objeto con una propiedad de claves que es un objeto de mapa de JavaScript. Esto mantendrá las letras individuales que son claves válidas de cada nodo. También hemos creado una propiedad final en los nodos que se pueden establecer en verdadero si el nodo representa la terminación de una palabra. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -60,6 +54,7 @@ var Trie = function() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,26 +1,16 @@
|
||||
---
|
||||
id: 587d825b367417b2b2512c8d
|
||||
title: Create an ES6 JavaScript Map
|
||||
localeTitle: Crear un mapa de JavaScript ES6
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear un mapa de JavaScript ES6
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
La nueva versión de JavaScript nos proporciona un objeto Map incorporado que proporciona gran parte de la funcionalidad que escribimos a mano en el último desafío. Este objeto de mapa, aunque similar a los objetos JavaScript normales, proporciona algunas funciones útiles de las que carecen los objetos normales. Por ejemplo, un mapa ES6 rastrea el orden de inserción de los elementos que se le agregan. Aquí hay una descripción más completa de sus métodos:
|
||||
<code>.has(key)</code> devuelve verdadero o falso según la presencia de una clave
|
||||
<code>.get(key)</code> devuelve el valor asociado con una clave
|
||||
<code>.set(key, value)</code> establece un nueva clave, valor par
|
||||
<code>.delete(key)</code> elimina una clave, valor par
|
||||
<code>.clear()</code> elimina toda clave, valor pares
|
||||
<code>.entries()</code> devuelve una matriz de todas las claves en orden de inserción
|
||||
<code>.values()</code> devuelve un matriz de todos los valores en orden de inserción
|
||||
Instrucciones: Defina un objeto de mapa de JavaScript y asígnele una variable llamada myMap. Agregue la clave, el par de valores <code>freeCodeCamp</code> , <code>Awesome!</code> lo.
|
||||
</section>
|
||||
<section id="description"> La nueva versión de JavaScript nos proporciona un objeto Map incorporado que proporciona gran parte de la funcionalidad que escribimos a mano en el último desafío. Este objeto de mapa, aunque similar a los objetos JavaScript normales, proporciona algunas funciones útiles de las que carecen los objetos normales. Por ejemplo, un mapa ES6 rastrea el orden de inserción de los elementos que se le agregan. Aquí hay una descripción más completa de sus métodos: <code>.has(key)</code> devuelve verdadero o falso según la presencia de una clave <code>.get(key)</code> devuelve el valor asociado con una clave <code>.set(key, value)</code> establece una nueva clave, el par de valores <code>.delete(key)</code> elimina una clave, el par de valores <code>.clear()</code> elimina todas las claves, los pares de valores <code>.entries()</code> devuelve una matriz de todas las claves en el orden de inserción <code>.values()</code> devuelve una matriz de todos los valores de la inserción Instrucciones de pedido: defina un objeto de mapa de JavaScript y asígnele una variable llamada myMap. Agregue la clave, el par de valores <code>freeCodeCamp</code> , <code>Awesome!</code> lo. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -30,7 +20,7 @@ Instrucciones: Defina un objeto de mapa de JavaScript y asígnele una variable l
|
||||
tests:
|
||||
- text: El objeto myMap existe.
|
||||
testString: 'assert(typeof myMap === "object", "The myMap object exists.");'
|
||||
- text: 'myMap contiene el par de valores clave <code clase = "notranslate"> freeCodeCamp </code>, <code clase = "notranslate"> ¡Impresionante! </code>.'
|
||||
- text: 'myMap contiene el par de valores clave <code>freeCodeCamp</code> , <code>Awesome!</code> .'
|
||||
testString: 'assert(myMap.get("freeCodeCamp") === "Awesome!", "myMap contains the key value pair <code>freeCodeCamp</code>, <code>Awesome!</code>.");'
|
||||
|
||||
```
|
||||
@ -44,6 +34,7 @@ tests:
|
||||
|
||||
```js
|
||||
// change code below this line
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,36 +1,23 @@
|
||||
---
|
||||
id: 587d8254367417b2b2512c70
|
||||
title: Create and Add to Sets in ES6
|
||||
localeTitle: Crear y agregar a conjuntos en ES6
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Crear y agregar a conjuntos en ES6
|
||||
---
|
||||
|
||||
## 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>
|
||||
<section id="description"> Ahora que has trabajado con ES5, vas 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. Veamos: 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 contiene solo [1, 2, 3] </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>
|
||||
<section id="instructions"> Para este ejercicio, devuelve un conjunto con los siguientes valores: <code>1, 2, 3, 'Taco', 'Cat', 'Awesome'</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Tu <code>Set</code> solo debe contener los valores <code>1, 2, 3, Taco, Cat, Awesome</code> '
|
||||
- text: 'Su <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>.");'
|
||||
|
||||
```
|
||||
@ -53,6 +40,7 @@ function checkSet() {
|
||||
}
|
||||
|
||||
checkSet();
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -64,10 +52,7 @@ checkSet();
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function checkSet(){var set = new Set([1,2,3,'Taco','Cat','Awesome']);
|
||||
return set;}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 587d8258367417b2b2512c80
|
||||
title: Delete a Leaf Node in a Binary Search Tree
|
||||
localeTitle: Eliminar un nodo de hoja en un árbol de búsqueda binario
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Eliminar un nodo de hoja en un árbol de búsqueda binario
|
||||
---
|
||||
|
||||
## 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>
|
||||
<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 de hoja: el objetivo que se eliminará tiene cero hijos. Un hijo: el objetivo a eliminar solo tiene un hijo. Dos hijos: el objetivo a eliminar tiene dos nodos hijos. Eliminar un nodo de 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>
|
||||
|
||||
## Tests
|
||||
@ -32,7 +24,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");'
|
||||
@ -58,6 +50,7 @@ function BinarySearchTree() {
|
||||
this.root = null;
|
||||
// case 1: target has no children, change code below this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,19 +1,16 @@
|
||||
---
|
||||
id: 587d8258367417b2b2512c81
|
||||
title: Delete a Node with One Child in a Binary Search Tree
|
||||
localeTitle: Eliminar un nodo con un hijo en un árbol de búsqueda binario
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Eliminar un nodo con un hijo en un árbol de búsqueda binario
|
||||
---
|
||||
|
||||
## 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>
|
||||
<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>
|
||||
|
||||
## Tests
|
||||
@ -27,13 +24,13 @@ 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");'
|
||||
- text: El método <code>remove</code> elimina los nodos con un hijo.
|
||||
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(-1); test.add(3); test.add(7); test.add(16); test.remove(16); test.remove(7); test.remove(3); return (test.inorder().join("") == "-1"); })(), "The <code>remove</code> method removes nodes with one child.");'
|
||||
- text: Al eliminar la raíz en un árbol con dos nodos, el segundo es la raíz.
|
||||
- text: 'Al eliminar la raíz en un árbol con dos nodos, el segundo es la raíz.'
|
||||
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(15); test.add(27); test.remove(15); return (test.inorder().join("") == "27"); })(), "Removing the root in a tree with two nodes sets the second to be the root.");'
|
||||
|
||||
```
|
||||
@ -98,6 +95,7 @@ function BinarySearchTree() {
|
||||
// case 2: target has one child, change code below this line
|
||||
};
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,20 +1,16 @@
|
||||
---
|
||||
id: 587d8258367417b2b2512c82
|
||||
title: Delete a Node with Two Children in a Binary Search Tree
|
||||
localeTitle: Eliminar un nodo con dos hijos en un árbol de búsqueda binario
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Eliminar un nodo con dos hijos en un árbol de búsqueda binario
|
||||
---
|
||||
|
||||
## 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>
|
||||
<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>
|
||||
|
||||
## Tests
|
||||
@ -28,13 +24,13 @@ 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");'
|
||||
- text: El método <code>remove</code> elimina los nodos con un hijo.
|
||||
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(-1); test.add(3); test.add(7); test.add(16); test.remove(16); test.remove(7); test.remove(3); return (test.inorder().join("") == "-1"); })(), "The <code>remove</code> method removes nodes with one child.");'
|
||||
- text: Al eliminar la raíz en un árbol con dos nodos, el segundo es la raíz.
|
||||
- text: 'Al eliminar la raíz en un árbol con dos nodos, el segundo es la raíz.'
|
||||
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(15); test.add(27); test.remove(15); return (test.inorder().join("") == "27"); })(), "Removing the root in a tree with two nodes sets the second to be the root.");'
|
||||
- text: El método de <code>remove</code> elimina los nodos con dos hijos mientras mantiene la estructura del árbol de búsqueda binario.
|
||||
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(1); test.add(4); test.add(3); test.add(7); test.add(9); test.add(11); test.add(14); test.add(15); test.add(19); test.add(50); test.remove(9); if (!test.isBinarySearchTree()) { return false; }; test.remove(11); if (!test.isBinarySearchTree()) { return false; }; test.remove(14); if (!test.isBinarySearchTree()) { return false; }; test.remove(19); if (!test.isBinarySearchTree()) { return false; }; test.remove(3); if (!test.isBinarySearchTree()) { return false; }; test.remove(50); if (!test.isBinarySearchTree()) { return false; }; test.remove(15); if (!test.isBinarySearchTree()) { return false; }; return (test.inorder().join("") == "147"); })(), "The <code>remove</code> method removes nodes with two children while maintaining the binary search tree structure.");'
|
||||
@ -117,6 +113,7 @@ function BinarySearchTree() {
|
||||
// case 3: target has two children, change code below this line
|
||||
};
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,46 +1,37 @@
|
||||
---
|
||||
id: 587d825d367417b2b2512c96
|
||||
title: Depth-First Search
|
||||
localeTitle: Búsqueda en profundidad
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Búsqueda en profundidad
|
||||
---
|
||||
|
||||
## 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>
|
||||
<section id="description"> De forma similar a la <dfn>búsqueda de amplitud en primer lugar</dfn> , aquí aprenderemos sobre otro algoritmo de recorrido de gráficos llamado <dfn>búsqueda de profundidad en primer lugar</dfn> . Mientras que la búsqueda de amplitud busca las longitudes de borde incrementales lejos del nodo de origen, la <dfn>búsqueda de profundidad primero</dfn> primero recorre un camino de bordes tan lejos como puede. Una vez que llegue 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"> Un resultado 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>
|
||||
<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
|
||||
<section id='tests'>
|
||||
|
||||
```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> debe 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> Debe 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> Debe 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> Debe 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> Debe 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> Debe 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> Debe 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> Debe 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.");'
|
||||
|
||||
```
|
||||
@ -64,6 +55,7 @@ var exDFSGraph = [
|
||||
[0, 0, 1, 0]
|
||||
];
|
||||
console.log(dfs(exDFSGraph, 3));
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -75,9 +67,7 @@ console.log(dfs(exDFSGraph, 3));
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function dfs(graph, root) { var stack = []; var tempV; var visited = []; var tempVNeighbors = []; stack.push(root); while (stack.length > 0) { tempV = stack.pop(); if (visited.indexOf(tempV) == -1) { visited.push(tempV); tempVNeighbors = graph[tempV]; for (var i = 0; i < tempVNeighbors.length; i++) { if (tempVNeighbors[i] == 1) { stack.push(i); }}}} return visited;}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 587d8257367417b2b2512c7d
|
||||
title: Find the Minimum and Maximum Height of a Binary Search Tree
|
||||
localeTitle: Encuentra la altura mínima y máxima de un árbol de búsqueda binario
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Encuentra la altura mínima y máxima de un árbol de búsqueda binario
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En el último desafío describimos un escenario en el que un árbol podría desequilibrarse. Para entender el concepto de equilibrio, echemos un vistazo a otra propiedad del árbol: la altura. La altura en un árbol representa la distancia desde el nodo raíz a cualquier nodo hoja dado. Diferentes caminos en una estructura de árbol altamente ramificada pueden tener diferentes alturas, pero para un árbol dado habrá una altura mínima y máxima. Si el árbol está equilibrado, estos valores diferirán como máximo en uno. Esto significa que en un árbol equilibrado, todos los nodos de hoja existen dentro del mismo nivel, o si no están dentro del mismo nivel, están a lo sumo en un nivel.
|
||||
La propiedad del equilibrio es importante para los árboles porque es lo que determina la eficiencia de las operaciones de los árboles. Como explicamos en el último desafío, enfrentamos la complejidad del peor de los casos para árboles muy desequilibrados. Los árboles de equilibrio automático se usan comúnmente para explicar este problema en árboles con conjuntos de datos dinámicos. Los ejemplos comunes de estos incluyen árboles AVL, árboles rojo-negros y árboles-B. Todos estos árboles contienen lógica interna adicional que vuelve a equilibrar el árbol cuando las inserciones o eliminaciones crean un estado de desequilibrio.
|
||||
Nota: una propiedad similar a la altura es la profundidad, que se refiere a qué tan lejos está un nodo dado del nodo raíz.
|
||||
Instrucciones: escriba dos métodos para nuestro árbol binario: <code>findMinHeight</code> y <code>findMaxHeight</code> . Estos métodos deben devolver un valor entero para la altura mínima y máxima dentro de un árbol binario dado, respectivamente. Si el nodo está vacío, asignémosle una altura de <code>-1</code> (ese es el caso base). Finalmente, agregue un tercer método <code>isBalanced</code> que devuelva <code>true</code> o <code>false</code> dependiendo de si el árbol está equilibrado o no. Puedes usar los dos primeros métodos que acabas de escribir para determinar esto.
|
||||
</section>
|
||||
<section id="description"> En el último desafío describimos un escenario en el que un árbol podría desequilibrarse. Para entender el concepto de equilibrio, echemos un vistazo a otra propiedad del árbol: la altura. La altura en un árbol representa la distancia desde el nodo raíz a cualquier nodo hoja dado. Diferentes caminos en una estructura de árbol altamente ramificada pueden tener diferentes alturas, pero para un árbol dado habrá una altura mínima y máxima. Si el árbol está equilibrado, estos valores diferirán como máximo en uno. Esto significa que en un árbol equilibrado, todos los nodos de hoja existen dentro del mismo nivel, o si no están dentro del mismo nivel, están a lo sumo en un nivel. La propiedad del equilibrio es importante para los árboles porque es lo que determina la eficiencia de las operaciones de los árboles. Como explicamos en el último desafío, enfrentamos la complejidad del peor de los casos para árboles muy desequilibrados. Los árboles de equilibrio automático se usan comúnmente para explicar este problema en árboles con conjuntos de datos dinámicos. Los ejemplos comunes de estos incluyen árboles AVL, árboles rojo-negros y árboles-B. Todos estos árboles contienen lógica interna adicional que vuelve a equilibrar el árbol cuando las inserciones o eliminaciones crean un estado de desequilibrio. Nota: una propiedad similar a la altura es la profundidad, que se refiere a qué tan lejos está un nodo dado del nodo raíz. Instrucciones: Escriba dos métodos para nuestro árbol binario: <code>findMinHeight</code> y <code>findMaxHeight</code> . Estos métodos deben devolver un valor entero para la altura mínima y máxima dentro de un árbol binario dado, respectivamente. Si el nodo está vacío, asignémosle una altura de <code>-1</code> (ese es el caso base). Finalmente, agregue un tercer método <code>isBalanced</code> que devuelva <code>true</code> o <code>false</code> dependiendo de si el árbol está equilibrado o no. Puedes usar los dos primeros métodos que acabas de escribir para determinar esto. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -61,6 +56,7 @@ function BinarySearchTree() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 587d8256367417b2b2512c7a
|
||||
title: Find the Minimum and Maximum Value in a Binary Search Tree
|
||||
localeTitle: Encuentre el valor mínimo y máximo en un árbol de búsqueda binario
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Encuentre el valor mínimo y máximo en un árbol de búsqueda binario
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Esta serie de desafíos introducirá la estructura de datos del árbol. Los árboles son una estructura de datos importante y versátil en informática. Por supuesto, su nombre proviene del hecho de que cuando se visualizan se parecen mucho a los árboles con los que estamos familiarizados en el mundo natural. Una estructura de datos de árbol comienza con un nodo, normalmente denominado raíz, y desde aquí se bifurca a nodos adicionales, cada uno de los cuales puede tener más nodos secundarios, y así sucesivamente. La estructura de datos generalmente se visualiza con el nodo raíz en la parte superior; Se puede pensar en él como un árbol natural al revés.
|
||||
Primero, describamos algunos términos comunes que encontraremos con los árboles. El nodo raíz es la parte superior del árbol. Los puntos de datos en el árbol se llaman nodos. Los nodos con ramas que conducen a otros nodos se conocen como el padre del nodo al que la rama lleva (el hijo). Otros términos familiares más complicados se aplican como podría esperarse. Un subárbol se refiere a todos los descendientes de un nodo particular, las ramas se pueden denominar bordes y los nodos de hoja son nodos al final del árbol que no tienen hijos. Finalmente, tenga en cuenta que los árboles son inherentemente estructuras de datos recursivas. Es decir, cualquier hijo de un nodo es padre de su propio subárbol, y así sucesivamente. Es importante entender la naturaleza recursiva de los árboles cuando se diseñan algoritmos para operaciones de árboles comunes.
|
||||
Para comenzar, discutiremos un tipo particular de árbol, el árbol binario. De hecho, discutiremos un árbol binario particular, un árbol de búsqueda binario. Vamos a describir lo que esto significa. Si bien la estructura de datos del árbol puede tener cualquier número de ramas en un solo nodo, un árbol binario solo puede tener dos ramas para cada nodo. Además, un árbol de búsqueda binario se ordena con respecto a los subárboles secundarios, de modo que el valor de cada nodo en el subárbol izquierdo es menor o igual que el valor del nodo principal, y el valor de cada nodo en el subárbol derecho es mayor o igual que el valor del nodo padre. Es muy útil visualizar esta relación para entenderla mejor:
|
||||
<div style='width: 100%; display: flex; justify-content: center; align-items: center;'><img style='width: 100%; max-width: 350px;' src='https://user-images.githubusercontent.com/18563015/32136009-1e665d98-bbd6-11e7-9133-63184f9f9182.png'></div>
|
||||
Ahora esta relación ordenada es muy fácil de ver. Tenga en cuenta que cada valor a la izquierda de 8, el nodo raíz, es menor que 8, y cada valor a la derecha es mayor que 8. También tenga en cuenta que esta relación se aplica también a cada uno de los subárboles. Por ejemplo, el primer hijo izquierdo es un subárbol. 3 es el nodo principal, y tiene exactamente dos nodos secundarios: según las reglas que gobiernan los árboles de búsqueda binarios, sabemos sin mirar que el elemento secundario izquierdo de este nodo (y cualquiera de sus elementos secundarios) será menor que 3, y el derecho child (y cualquiera de sus hijos) será mayor que 3 (pero también menor que el valor raíz de la estructura), y así sucesivamente.
|
||||
Los árboles de búsqueda binarios son estructuras de datos muy comunes y útiles porque proporcionan tiempo logarítmico en el caso promedio para varias operaciones comunes, como búsqueda, inserción y eliminación.
|
||||
Instrucciones: Empezaremos simple. Aquí hemos definido el esqueleto de una estructura de árbol de búsqueda binaria además de una función para crear nodos para nuestro árbol. Observe que cada nodo puede tener un valor izquierdo y derecho. A estos se les asignarán subárboles secundarios si existen. En nuestro árbol de búsqueda binario, defina dos métodos, <code>findMin</code> y <code>findMax</code> . Estos métodos deben devolver el valor mínimo y máximo retenido en el árbol de búsqueda binario (no se preocupe por agregar valores al árbol por ahora, hemos agregado algunos en el fondo). Si te quedas atascado, reflexiona sobre el invariante que debe ser cierto para los árboles de búsqueda binarios: cada subárbol izquierdo es menor o igual que su principal y cada subárbol derecho es mayor o igual que su principal. Digamos también que nuestro árbol solo puede almacenar valores enteros. Si el árbol está vacío, cualquiera de los métodos debe devolver <code>null</code> .
|
||||
</section>
|
||||
<section id="description"> Esta serie de desafíos introducirá la estructura de datos del árbol. Los árboles son una estructura de datos importante y versátil en informática. Por supuesto, su nombre proviene del hecho de que cuando se visualizan se parecen mucho a los árboles con los que estamos familiarizados en el mundo natural. Una estructura de datos de árbol comienza con un nodo, normalmente denominado raíz, y desde aquí se bifurca a nodos adicionales, cada uno de los cuales puede tener más nodos secundarios, y así sucesivamente. La estructura de datos generalmente se visualiza con el nodo raíz en la parte superior; Se puede pensar en él como un árbol natural al revés. Primero, describamos una terminología común que encontraremos con los árboles. El nodo raíz es la parte superior del árbol. Los puntos de datos en el árbol se llaman nodos. Los nodos con ramas que conducen a otros nodos se conocen como el padre del nodo al que la rama lleva (el hijo). Otros términos familiares más complicados se aplican como podría esperarse. Un subárbol se refiere a todos los descendientes de un nodo particular, las ramas se pueden denominar bordes y los nodos de hoja son nodos al final del árbol que no tienen hijos. Finalmente, tenga en cuenta que los árboles son inherentemente estructuras de datos recursivas. Es decir, cualquier hijo de un nodo es padre de su propio subárbol, y así sucesivamente. Es importante entender la naturaleza recursiva de los árboles cuando se diseñan algoritmos para operaciones de árboles comunes. Para comenzar, discutiremos un tipo particular de árbol, el árbol binario. De hecho, discutiremos un árbol binario particular, un árbol de búsqueda binario. Vamos a describir lo que esto significa. Si bien la estructura de datos del árbol puede tener cualquier número de ramas en un solo nodo, un árbol binario solo puede tener dos ramas para cada nodo. Además, un árbol de búsqueda binario se ordena con respecto a los subárboles secundarios, de modo que el valor de cada nodo en el subárbol izquierdo es menor o igual que el valor del nodo principal, y el valor de cada nodo en el subárbol derecho es mayor o igual que el valor del nodo padre. Es muy útil visualizar esta relación para entenderla mejor: <div style="width: 100%; display: flex; justify-content: center; align-items: center;"><img style="width: 100%; max-width: 350px;" src="https://user-images.githubusercontent.com/18563015/32136009-1e665d98-bbd6-11e7-9133-63184f9f9182.png"></div> Ahora esta relación ordenada es muy fácil de ver. Tenga en cuenta que cada valor a la izquierda de 8, el nodo raíz, es menor que 8, y cada valor a la derecha es mayor que 8. También tenga en cuenta que esta relación se aplica también a cada uno de los subárboles. Por ejemplo, el primer hijo izquierdo es un subárbol. 3 es el nodo principal, y tiene exactamente dos nodos secundarios: según las reglas que gobiernan los árboles de búsqueda binarios, sabemos sin mirar que el elemento secundario izquierdo de este nodo (y cualquiera de sus elementos secundarios) será menor que 3, y el derecho child (y cualquiera de sus hijos) será mayor que 3 (pero también menor que el valor raíz de la estructura), y así sucesivamente. Los árboles de búsqueda binarios son estructuras de datos muy comunes y útiles porque proporcionan tiempo logarítmico en el caso promedio para varias operaciones comunes, como búsqueda, inserción y eliminación. Instrucciones: Vamos a empezar simple. Aquí hemos definido el esqueleto de una estructura de árbol de búsqueda binaria además de una función para crear nodos para nuestro árbol. Observe que cada nodo puede tener un valor izquierdo y derecho. A estos se les asignarán subárboles secundarios si existen. En nuestro árbol de búsqueda binario, defina dos métodos, <code>findMin</code> y <code>findMax</code> . Estos métodos deben devolver el valor mínimo y máximo retenido en el árbol de búsqueda binario (no se preocupe por agregar valores al árbol por ahora, hemos agregado algunos en el fondo). Si te quedas atascado, reflexiona sobre el invariante que debe ser cierto para los árboles de búsqueda binarios: cada subárbol izquierdo es menor o igual que su principal y cada subárbol derecho es mayor o igual que su principal. Digamos también que nuestro árbol solo puede almacenar valores enteros. Si el árbol está vacío, cualquiera de los métodos debe devolver <code>null</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -60,6 +52,7 @@ function BinarySearchTree() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,20 +1,16 @@
|
||||
---
|
||||
id: 587d825b367417b2b2512c8c
|
||||
title: Implement Heap Sort with a Min Heap
|
||||
localeTitle: Implementar Heap Sort con un Min Heap
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Implementar Heap Sort con un Min Heap
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora que podemos agregar y eliminar elementos, veamos algunas aplicaciones en las que se pueden usar los montones. Los montones se usan comúnmente para implementar colas de prioridad porque siempre almacenan un artículo de mayor o menor valor en la primera posición. Además, se utilizan para implementar un algoritmo de clasificación denominado ordenación de pila. Veremos cómo hacer esto aquí. La clasificación de montones utiliza un montón mínimo, lo contrario de un montón máximo. Un montón mínimo siempre almacena el elemento de menor valor en la posición raíz.
|
||||
ordenación de montones funciona tomando una matriz sin clasificar, agregando cada elemento de la matriz a un montón mínimo y luego extrayendo cada elemento de la pila mínima a una nueva matriz. La estructura de almacenamiento dinámico mínimo garantiza que la nueva matriz contendrá los elementos originales en el orden más pequeño al más grande. Este es uno de los algoritmos de clasificación más eficientes con un rendimiento promedio y en el peor de los casos de O (nlog (n)).
|
||||
Instrucciones: Implementemos la ordenación de pila con una pila mínima. Siéntase libre de adaptar su código de pila máxima aquí. Cree un objeto MinHeap con métodos de insertar, eliminar y ordenar. El método de clasificación debe devolver una matriz de todos los elementos en el montón mínimo ordenados de menor a mayor.
|
||||
</section>
|
||||
<section id="description"> Ahora que podemos agregar y eliminar elementos, veamos algunas de las aplicaciones en que se pueden usar los montones. Los montones se usan comúnmente para implementar colas de prioridad porque siempre almacenan un artículo de mayor o menor valor en la primera posición. Además, se utilizan para implementar un algoritmo de clasificación denominado ordenación de pila. Veremos cómo hacer esto aquí. La clasificación de montones utiliza un montón mínimo, lo contrario de un montón máximo. Un montón mínimo siempre almacena el elemento de menor valor en la posición raíz. La ordenación de montones funciona tomando una matriz sin clasificar, agregando cada elemento de la matriz a un montón mínimo y luego extrayendo cada elemento de la pila mínima a una nueva matriz. La estructura de almacenamiento dinámico mínimo garantiza que la nueva matriz contendrá los elementos originales en el orden más pequeño al más grande. Este es uno de los algoritmos de clasificación más eficientes con un rendimiento promedio y en el peor de los casos de O (nlog (n)). Instrucciones: Implementemos la ordenación de pilas con una pila mínima. Siéntase libre de adaptar su código de pila máxima aquí. Cree un objeto MinHeap con métodos de insertar, eliminar y ordenar. El método de clasificación debe devolver una matriz de todos los elementos en el montón mínimo ordenados de menor a mayor. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -58,6 +54,7 @@ var MinHeap = function() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,31 +1,16 @@
|
||||
---
|
||||
id: 587d8256367417b2b2512c79
|
||||
title: Incidence Matrix
|
||||
localeTitle: Matriz de incidencia
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Matriz de incidencia
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Otra forma de representar una gráfica es colocarla en una <dfn>matriz de incidencia.</dfn>
|
||||
Una <dfn>matriz de incidencia</dfn> es una <dfn>matriz</dfn> bidimensional (2D). En términos generales, una matriz de incidencia relaciona dos clases diferentes de objetos entre sus dos dimensiones. Este tipo de matriz es similar a una matriz de adyacencia. Sin embargo, las filas y columnas significan algo más aquí.
|
||||
En las gráficas, tenemos aristas y nodos. Estas serán nuestras "dos clases diferentes de objetos". Esta matriz tendrá las filas, los nodos y las columnas, los bordes. Esto significa que podemos tener un número desigual de filas y columnas.
|
||||
Cada columna representará un borde único. Además, cada borde conecta dos nodos. Para mostrar que hay un borde entre dos nodos, colocará un 1 en las dos filas de una columna en particular. A continuación se muestra un gráfico de 3 nodos con un borde entre el nodo 1 y el nodo 3.
|
||||
<blockquote> 1<br> ---<br>1 | 1<br>2 | 0<br>3 | 1</blockquote>
|
||||
Aquí hay un ejemplo de una <code>incidence matrix</code> con 4 aristas y 4 nodos. Recuerde, las columnas son los bordes y las filas son los nodos mismos.
|
||||
<blockquote> 1 2 3 4<br> --------<br>1 | 0 1 1 1<br>2 | 1 1 0 0<br>3 | 1 0 0 1<br>4 | 0 0 1 0</blockquote>
|
||||
A continuación se muestra una implementación de JavaScript de la misma cosa.
|
||||
<blockquote>var incMat = [<br> [0, 1, 1, 1],<br> [1, 1, 0, 0],<br> [1, 0, 0, 1],<br> [0, 0, 1, 0]<br>];</blockquote>
|
||||
Para hacer un gráfico dirigido, use <code>-1</code> para un borde que sale de un nodo particular y <code>1</code> para un borde que ingresa a un nodo.
|
||||
<blockquote>var incMatDirected = [<br> [ 0, -1, 1, -1],<br> [-1, 1, 0, 0],<br> [ 1, 0, 0, 1],<br> [ 0, 0, -1, 0]<br>];</blockquote>
|
||||
gráficos también pueden tener <dfn>pesos</dfn> en sus bordes. Hasta ahora, tenemos bordes <dfn>no ponderados</dfn> donde solo la presencia y la falta de borde es binaria ( <code>0</code> o <code>1</code> ). Puede tener diferentes pesos dependiendo de su aplicación. Un peso diferente se representa como números mayores que 1.
|
||||
</section>
|
||||
<section id="description"> Otra forma de representar una gráfica es colocarla en una <dfn>matriz de incidencia.</dfn> Una <dfn>matriz de incidencia</dfn> es una <dfn>matriz</dfn> bidimensional (2D). En términos generales, una matriz de incidencia relaciona dos clases diferentes de objetos entre sus dos dimensiones. Este tipo de matriz es similar a una matriz de adyacencia. Sin embargo, las filas y columnas significan algo más aquí. En las gráficas, tenemos aristas y nodos. Estas serán nuestras "dos clases diferentes de objetos". Esta matriz tendrá las filas, los nodos y las columnas, los bordes. Esto significa que podemos tener un número desigual de filas y columnas. Cada columna representará un borde único. Además, cada borde conecta dos nodos. Para mostrar que hay un borde entre dos nodos, colocará un 1 en las dos filas de una columna en particular. A continuación se muestra un gráfico de 3 nodos con un borde entre el nodo 1 y el nodo 3. <blockquote> 1 <br> --- <br> 1 | 1 <br> 2 | 0 <br> 3 | 1 </blockquote> Aquí hay un ejemplo de una <code>incidence matrix</code> con 4 aristas y 4 nodos. Recuerde, las columnas son los bordes y las filas son los nodos mismos. <blockquote> 1 2 3 4 <br> -------- <br> 1 | 0 1 1 1 <br> 2 | 1 1 0 0 <br> 3 | 1 0 0 1 <br> 4 | 0 0 1 0 </blockquote> A continuación se muestra una implementación de JavaScript de la misma cosa. <blockquote> var incMat = [ <br> [0, 1, 1, 1], <br> [1, 1, 0, 0], <br> [1, 0, 0, 1], <br> [0, 0, 1, 0] <br> ]; </blockquote> Para hacer un gráfico dirigido, use <code>-1</code> para un borde que sale de un nodo particular y <code>1</code> para un borde que ingresa a un nodo. <blockquote> var incMatDirected = [ <br> [0, -1, 1, -1], <br> [-1, 1, 0, 0], <br> [1, 0, 0, 1], <br> [0, 0, -1, 0] <br> ]; </blockquote> Los gráficos también pueden tener <dfn>pesos</dfn> en sus bordes. Hasta ahora, tenemos bordes <dfn>no ponderados</dfn> donde solo la presencia y la falta de borde es binaria ( <code>0</code> o <code>1</code> ). Puede tener diferentes pesos dependiendo de su aplicación. Un peso diferente se representa como números mayores que 1. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Cree una matriz de incidencia de un gráfico no dirigido con cinco nodos y cuatro bordes. Esta matriz debe estar en una matriz multidimensional.
|
||||
Estos cinco nodos tienen relaciones siguiendo relaciones. El primer borde está entre el primer y el segundo nodo. El segundo borde está entre el segundo y tercer nodo. El tercer borde está entre el tercer y quinto nodo. Y el borde cuatro está entre el cuarto y el segundo nodo. Todos los pesos de borde son uno y el orden de borde es importante.
|
||||
</section>
|
||||
<section id="instructions"> Cree una matriz de incidencia de un gráfico no dirigido con cinco nodos y cuatro bordes. Esta matriz debe estar en una matriz multidimensional. Estos cinco nodos tienen relaciones siguiendo relaciones El primer borde está entre el primer y el segundo nodo. El segundo borde está entre el segundo y tercer nodo. El tercer borde está entre el tercer y quinto nodo. Y el borde cuatro está entre el cuarto y el segundo nodo. Todos los pesos de borde son uno y el orden de borde es importante. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@ -56,6 +41,7 @@ tests:
|
||||
var incMatUndirected = [
|
||||
|
||||
];
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -67,9 +53,7 @@ var incMatUndirected = [
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var incMatUndirected = [[1, 0, 0, 0],[1, 1, 0, 1],[0, 1, 1, 0],[0, 0, 0, 1],[0, 0, 1, 0]];
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,33 +1,16 @@
|
||||
---
|
||||
id: 587d825a367417b2b2512c8a
|
||||
title: Insert an Element into a Max Heap
|
||||
localeTitle: Insertar un elemento en un montón máximo
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Insertar un elemento en un montón máximo
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora vamos a pasar a otra estructura de datos de árbol, el montón binario. Un montón binario es un árbol binario parcialmente ordenado que satisface la propiedad de montón. La propiedad del montón especifica una relación entre los nodos padre e hijo. Puede tener un montón máximo, en el que todos los nodos principales son mayores o iguales que sus nodos secundarios, o un montón mínimo, en el que lo contrario es cierto. Los montones binarios también son árboles binarios completos. Esto significa que todos los niveles del árbol están completamente llenos y si el último nivel está parcialmente lleno, se llenará de izquierda a derecha.
|
||||
Mientras que los montones binarios se pueden implementar como estructuras de árbol con nodos que contienen referencias a la izquierda y a la derecha, el orden parcial de acuerdo con la propiedad del montón nos permite representar el montón con una matriz. Lo que nos interesa es la relación padre-hijo y con aritmética simple podemos calcular los hijos de cualquier padre y el padre de cualquier nodo hijo.
|
||||
Por ejemplo, considere esta representación matricial de un montón binario mínimo:
|
||||
<code>[ 6, 22, 30, 37, 63, 48, 42, 76 ]</code>
|
||||
El nodo raíz es el primer elemento, 6. Sus hijos son 22 y 30. Si observamos la relación entre los índices de matriz de estos valores, para el índice i, los hijos son 2 * i + 1 y 2 * i + 2. Del mismo modo, el elemento en el índice 0 es el padre de estos dos hijos en los índices 1 y 2. Más generalmente, podemos encontrar el padre de un nodo en cualquier índice con lo siguiente: (i - 1) / 2. Estos patrones se mantendrán como verdaderos a medida que el árbol binario crezca a cualquier tamaño. Finalmente, podemos hacer un ligero ajuste para facilitar aún más esta aritmética al omitir el primer elemento de la matriz. Al hacer esto, se crea la siguiente relación para cualquier elemento en un índice dado i:
|
||||
Ejemplo Representación de matriz:
|
||||
<code>[ null, 6, 22, 30, 37, 63, 48, 42, 76 ]</code>
|
||||
Hijo de un elemento a la izquierda: i * 2
|
||||
El elemento derecho de un elemento: i * 2 + 1
|
||||
El elemento primario de un elemento: i / 2
|
||||
Una vez que encierre su cabeza alrededor de las matemáticas, usar una representación de matriz es muy útil porque las ubicaciones de los nodos se pueden determinar rápidamente con esta aritmética y el uso de la memoria disminuye. porque no es necesario mantener las referencias a los nodos secundarios.
|
||||
Instrucciones: Aquí crearemos un montón máximo. Comience simplemente creando un método de inserción que agregue elementos a nuestro montón. Durante la inserción, es importante mantener siempre la propiedad de montón. Para un montón máximo, esto significa que el elemento raíz siempre debe tener el mayor valor en el árbol y todos los nodos primarios deben ser mayores que sus secundarios. Para una implementación de matriz de un montón, esto normalmente se logra en tres pasos:
|
||||
Agregue el nuevo elemento al final de la matriz.
|
||||
Si el elemento es más grande que sus padres, cámbielos.
|
||||
Continúa cambiando hasta que el nuevo elemento sea más pequeño que su padre o llegues a la raíz del árbol.
|
||||
Finalmente, agregue un método de impresión que devuelva una matriz de todos los elementos que se han agregado al montón.
|
||||
</section>
|
||||
<section id="description"> Ahora pasaremos a otra estructura de datos de árbol, el montón binario. Un montón binario es un árbol binario parcialmente ordenado que satisface la propiedad de montón. La propiedad del montón especifica una relación entre los nodos padre e hijo. Puede tener un montón máximo, en el que todos los nodos principales son mayores o iguales que sus nodos secundarios, o un montón mínimo, en el que lo contrario es cierto. Los montones binarios también son árboles binarios completos. Esto significa que todos los niveles del árbol están completamente llenos y si el último nivel está parcialmente lleno, se llenará de izquierda a derecha. Si bien los montones binarios se pueden implementar como estructuras de árbol con nodos que contienen referencias a la izquierda y a la derecha, el orden parcial de acuerdo con la propiedad del montón nos permite representar el montón con una matriz. Lo que nos interesa es la relación padre-hijo y con aritmética simple podemos calcular los hijos de cualquier padre y el padre de cualquier nodo hijo. Por ejemplo, considere esta representación matricial de un montón binario mínimo: <code>[ 6, 22, 30, 37, 63, 48, 42, 76 ]</code> El nodo raíz es el primer elemento, 6. Sus hijos son 22 y 30. Si miramos en la relación entre los índices de matriz de estos valores, para el índice i, los hijos son 2 * i + 1 y 2 * i + 2. Del mismo modo, el elemento en el índice 0 es el padre de estos dos hijos en los índices 1 y 2. Más en general, podemos encontrar el padre de un nodo en cualquier índice con lo siguiente: (i - 1) / 2. Estos patrones se mantendrán como verdaderos a medida que el árbol binario crezca a cualquier tamaño. Finalmente, podemos hacer un ligero ajuste para facilitar aún más esta aritmética al omitir el primer elemento de la matriz. Al hacer esto, se crea la siguiente relación para cualquier elemento en un índice i: Ejemplo de representación en una matriz: <code>[ null, 6, 22, 30, 37, 63, 48, 42, 76 ]</code> Hijo izquierdo de un elemento: i * 2 Hijo derecho de un elemento : i * 2 + 1 El elemento primario de un elemento: i / 2 Una vez que encierre la cabeza alrededor de las matemáticas, usar una representación de matriz es muy útil porque las ubicaciones de los nodos se pueden determinar rápidamente con esta aritmética y el uso de la memoria se reduce porque no es necesario Mantener referencias a nodos hijos. Instrucciones: Aquí vamos a crear un montón máximo. Comience simplemente creando un método de inserción que agregue elementos a nuestro montón. Durante la inserción, es importante mantener siempre la propiedad de montón. Para un montón máximo, esto significa que el elemento raíz siempre debe tener el mayor valor en el árbol y todos los nodos primarios deben ser mayores que sus secundarios. Para una implementación de matriz de un montón, esto normalmente se logra en tres pasos: Agregar el nuevo elemento al final de la matriz. Si el elemento es más grande que sus padres, cámbielos. Continúa cambiando hasta que el nuevo elemento sea más pequeño que su padre o llegues a la raíz del árbol. Finalmente, agregue un método de impresión que devuelva una matriz de todos los elementos que se han agregado al montón. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -58,6 +41,7 @@ var MaxHeap = function() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,18 +1,16 @@
|
||||
---
|
||||
id: 587d8259367417b2b2512c83
|
||||
title: Invert a Binary Tree
|
||||
localeTitle: Invertir un árbol binario
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Invertir un árbol binario
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Aquí crearemos una función para invertir un árbol binario. Dado un árbol binario, queremos producir un nuevo árbol que sea equivalente a la imagen de espejo de este árbol. La ejecución de un recorrido inorder en un árbol invertido explorará los nodos en orden inverso en comparación con el recorrido inorder del árbol original. Escribe un método para hacer esto llamado <code>invert</code> en nuestro árbol binario. Llamar a este método debería invertir la estructura de árbol actual. Idealmente, nos gustaría hacer esto in situ en tiempo lineal. Es decir, solo visitamos cada nodo una vez y modificamos la estructura de árbol existente a medida que avanzamos, sin utilizar ninguna memoria adicional. ¡Buena suerte!
|
||||
</section>
|
||||
<section id="description"> Aquí vamos a crear una función para invertir un árbol binario. Dado un árbol binario, queremos producir un nuevo árbol que sea equivalente a la imagen de espejo de este árbol. La ejecución de un recorrido inorder en un árbol invertido explorará los nodos en orden inverso en comparación con el recorrido inorder del árbol original. Escribe un método para hacer esto llamado <code>invert</code> en nuestro árbol binario. Llamar a este método debería invertir la estructura de árbol actual. Idealmente, nos gustaría hacer esto in situ en tiempo lineal. Es decir, solo visitamos cada nodo una vez y modificamos la estructura de árbol existente a medida que avanzamos, sin utilizar ninguna memoria adicional. ¡Buena suerte! </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -50,6 +48,7 @@ function BinarySearchTree() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 587d8250367417b2b2512c5e
|
||||
title: Learn how a Stack Works
|
||||
localeTitle: Aprende cómo funciona una pila
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Aprende cómo funciona una pila
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Probablemente esté familiarizado con la pila de libros en su mesa. Es probable que haya utilizado la función de deshacer de un editor de texto. También es probable que esté acostumbrado a presionar el botón Atrás de su teléfono para volver a la vista anterior en su aplicación.
|
||||
¿Sabes lo que todos tienen en común? Todos ellos almacenan los datos de una manera que puede desplazarse hacia atrás.
|
||||
El libro más alto de la pila fue el que se colocó allí por última vez. Si quita ese libro de la parte superior de su pila, expondría el libro que se colocó allí antes del último libro y así sucesivamente.
|
||||
Si lo piensa, en todos los ejemplos anteriores, está recibiendo el tipo de servicio de <dfn>último en</dfn> entrar <dfn>, primero en salir</dfn> . Intentaremos imitar esto con nuestro código.
|
||||
Este esquema de almacenamiento de datos se llama una <dfn>pila</dfn> . En particular, tendríamos que implementar el método <code>push()</code> que empuja los objetos JavaScript en la parte superior de la pila; y el método <code>pop()</code> , que elimina el objeto JavaScript que está en la parte superior de la pila en el momento actual.
|
||||
</section>
|
||||
<section id="description"> Probablemente esté familiarizado con la pila de libros en su mesa. Es probable que haya utilizado la función de deshacer de un editor de texto. También es probable que esté acostumbrado a presionar el botón Atrás de su teléfono para volver a la vista anterior en su aplicación. ¿Sabes lo que todos tienen en común? Todos ellos almacenan los datos de una manera que puede desplazarse hacia atrás. El libro más alto de la pila fue el que se colocó allí por última vez. Si quita ese libro de la parte superior de su pila, expondría el libro que se colocó allí antes del último libro y así sucesivamente. Si lo piensa, en todos los ejemplos anteriores, está recibiendo el tipo de servicio de <dfn>último en</dfn> entrar <dfn>, primero en salir</dfn> . Intentaremos imitar esto con nuestro código. Este esquema de almacenamiento de datos se llama una <dfn>pila</dfn> . En particular, tendríamos que implementar el método <code>push()</code> que empuja los objetos JavaScript en la parte superior de la pila; y el método <code>pop()</code> , que elimina el objeto JavaScript que está en la parte superior de la pila en el momento actual. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Aquí tenemos una pila de asignaciones de tareas representadas como una matriz: <code>"BIO12"</code> está en la base, y <code>"PSY44"</code> está en la parte superior de la pila.
|
||||
Modifique la matriz dada y trátela como una <code>stack</code> usando los métodos de JavaScript mencionados anteriormente. Retire el elemento superior <code>"PSY44"</code> de la pila. Luego agrega <code>"CS50"</code> para que sea el nuevo elemento superior de la pila.
|
||||
</section>
|
||||
<section id="instructions"> Aquí tenemos una pila de asignaciones de tareas representadas como una matriz: <code>"BIO12"</code> está en la base, y <code>"PSY44"</code> está en la parte superior de la pila. Modifique la matriz dada y trátela como una <code>stack</code> usando los métodos de JavaScript mencionados anteriormente. Retire el elemento superior <code>"PSY44"</code> de la pila. Luego agrega <code>"CS50"</code> para que sea el nuevo elemento superior de la pila. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
@ -1,19 +1,16 @@
|
||||
---
|
||||
id: 587d8254367417b2b2512c6e
|
||||
title: Perform a Difference on Two Sets of Data
|
||||
localeTitle: Realizar una diferencia en dos conjuntos de datos
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Realizar una diferencia en dos conjuntos de datos
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En este ejercicio vamos a realizar una diferencia en 2 conjuntos de datos. Crearemos un método en nuestra estructura de datos de <code>Set</code> llamada <code>difference</code> . Una diferencia de conjuntos debe comparar dos conjuntos y devolver los elementos presentes en el primer conjunto que están ausentes en el segundo. Este método debe tomar otro <code>Set</code> como argumento y devolver la <code>difference</code> de los dos conjuntos.
|
||||
Por ejemplo, si <code>setA = ['a','b','c']</code> y <code>setB = ['a','b','d','e']</code> , entonces la diferencia de setA y setB es: <code>setA.difference(setB) = ['c']</code> .
|
||||
</section>
|
||||
<section id="description"> En este ejercicio vamos a realizar una diferencia en 2 conjuntos de datos. Crearemos un método en nuestra estructura de datos de <code>Set</code> llamada <code>difference</code> . Una diferencia de conjuntos debe comparar dos conjuntos y devolver los elementos presentes en el primer conjunto que están ausentes en el segundo. Este método debe tomar otro <code>Set</code> como argumento y devolver la <code>difference</code> de los dos conjuntos. Por ejemplo, si <code>setA = ['a','b','c']</code> y <code>setB = ['a','b','d','e']</code> , entonces la diferencia de setA y setB es: <code>setA.difference(setB) = ['c']</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -95,6 +92,7 @@ function Set() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -106,9 +104,7 @@ function Set() {
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function Set() {var collection = []; this.has = function(e){return(collection.indexOf(e) !== -1);};this.values = function() {return collection;};this.add = function(element) {if (!this.has(element)) {collection.push(element);return true;} else {return false;}};this.remove = function(element) {if(this.has(element)) {var i = collection.indexOf(element);collection.splice(i, 1);return true;}return false;};this.size = function() {return collection.length;};this.union = function(set) {var u = new Set();var c = this.values();var s = set.values();c.forEach(function(element){u.add(element);});s.forEach(function(element){u.add(element);});return u;};this.intersection = function(set) {var i = new Set();var c = this.values();c.forEach(function(element){if(s.has(element)) i.add(element);});};this.difference = function(set) {var d = new Set();var c = this.values();c.forEach(function(e){if(!set.has(e)) d.add(e);});};}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,19 +1,16 @@
|
||||
---
|
||||
id: 587d8254367417b2b2512c6f
|
||||
title: Perform a Subset Check on Two Sets of Data
|
||||
localeTitle: Realizar una verificación de subconjunto en dos conjuntos de datos
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Realizar una verificación de subconjunto en dos conjuntos de datos
|
||||
---
|
||||
|
||||
## 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>
|
||||
<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>
|
||||
|
||||
## Tests
|
||||
@ -25,13 +22,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>");'
|
||||
|
||||
```
|
||||
@ -114,6 +111,7 @@ function Set() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -125,9 +123,7 @@ function Set() {
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function Set() {var collection = []; this.has = function(e){return(collection.indexOf(e) !== -1);};this.values = function() {return collection;};this.add = function(element) {if (!this.has(element)) {collection.push(element);return true;} else {return false;}};this.remove = function(element) {if(this.has(element)) {var i = collection.indexOf(element);collection.splice(i, 1);return true;}return false;};this.size = function() {return collection.length;};this.union = function(set) {var u = new Set();var c = this.values();var s = set.values();c.forEach(function(element){u.add(element);});s.forEach(function(element){u.add(element);});return u;};this.intersection = function(set) {var i = new Set();var c = this.values();c.forEach(function(element){if(s.has(element)) i.add(element);});};this.difference = function(set) {var d = new Set();var c = this.values();c.forEach(function(e){if(!set.has(e)) d.add(e);});};this.subset = function(set) {var isSubset = true;var c = this.values();c.forEach(function(e){if(!set.has(e)) isSubset = false;});return isSubset;};}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,19 +1,16 @@
|
||||
---
|
||||
id: 587d8253367417b2b2512c6c
|
||||
title: Perform a Union on Two Sets
|
||||
localeTitle: Realizar una unión en dos sets
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Realizar una unión en dos sets
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En este ejercicio vamos a realizar una unión en dos conjuntos de datos. Crearemos un método en nuestra estructura de datos de <code>Set</code> llamada <code>union</code> . Este método debe tomar otro <code>Set</code> como argumento y devolver la <code>union</code> de los dos conjuntos, excluyendo cualquier valor duplicado.
|
||||
Por ejemplo, si <code>setA = ['a','b','c']</code> y <code>setB = ['a','b','d','e']</code> , entonces la unión de setA y setB es: <code>setA.union(setB) = ['a', 'b', 'c', 'd', 'e']</code> .
|
||||
</section>
|
||||
<section id="description"> En este ejercicio vamos a realizar una unión en dos conjuntos de datos. Crearemos un método en nuestra estructura de datos de <code>Set</code> llamada <code>union</code> . Este método debe tomar otro <code>Set</code> como argumento y devolver la <code>union</code> de los dos conjuntos, excluyendo cualquier valor duplicado. Por ejemplo, si <code>setA = ['a','b','c']</code> y <code>setB = ['a','b','d','e']</code> , entonces la unión de setA y setB es: <code>setA.union(setB) = ['a', 'b', 'c', 'd', 'e']</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -72,6 +69,7 @@ function Set() {
|
||||
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -83,9 +81,7 @@ function Set() {
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function Set() {var collection = []; this.has = function(e){return(collection.indexOf(e) !== -1);};this.values = function() {return collection;};this.add = function(element) {if (!this.has(element)) {collection.push(element);return true;} else {return false;}};this.remove = function(element) {if(this.has(element)) {var i = collection.indexOf(element);collection.splice(i, 1);return true;}return false;};this.size = function() {return collection.length;};this.union = function(set) {var u = new Set();var c = this.values();var s = set.values();c.forEach(function(element){u.add(element);});s.forEach(function(element){u.add(element);});return u;};}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,19 +1,16 @@
|
||||
---
|
||||
id: 587d8253367417b2b2512c6d
|
||||
title: Perform an Intersection on Two Sets of Data
|
||||
localeTitle: Realizar una intersección en dos conjuntos de datos
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Realizar una intersección en dos conjuntos de datos
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En este ejercicio vamos a realizar una intersección en 2 conjuntos de datos. Crearemos un método en nuestra estructura de datos del <code>Set</code> llamada <code>intersection</code> . Una intersección de conjuntos representa todos los valores que son comunes a dos o más conjuntos. Este método debe tomar otro <code>Set</code> como argumento y devolver la <code>intersection</code> de los dos conjuntos.
|
||||
Por ejemplo, si <code>setA = ['a','b','c']</code> y <code>setB = ['a','b','d','e']</code> , entonces la intersección de setA y setB es: <code>setA.intersection(setB) = ['a', 'b']</code> .
|
||||
</section>
|
||||
<section id="description"> En este ejercicio vamos a realizar una intersección en 2 conjuntos de datos. Crearemos un método en nuestra estructura de datos del <code>Set</code> llamada <code>intersection</code> . Una intersección de conjuntos representa todos los valores que son comunes a dos o más conjuntos. Este método debe tomar otro <code>Set</code> como argumento y devolver la <code>intersection</code> de los dos conjuntos. Por ejemplo, si <code>setA = ['a','b','c']</code> y <code>setB = ['a','b','d','e']</code> , entonces la intersección de setA y setB es: <code>setA.intersection(setB) = ['a', 'b']</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -84,6 +81,7 @@ function Set() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -95,9 +93,7 @@ function Set() {
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function Set() {var collection = []; this.has = function(e){return(collection.indexOf(e) !== -1);};this.values = function() {return collection;};this.add = function(element) {if (!this.has(element)) {collection.push(element);return true;} else {return false;}};this.remove = function(element) {if(this.has(element)) {var i = collection.indexOf(element);collection.splice(i, 1);return true;}return false;};this.size = function() {return collection.length;};this.union = function(set) {var u = new Set();var c = this.values();var s = set.values();c.forEach(function(element){u.add(element);});s.forEach(function(element){u.add(element);});return u;};this.intersection = function(set) {var i = new Set();var c = this.values();c.forEach(function(element){if(s.has(element)) i.add(element);});};}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,22 +1,16 @@
|
||||
---
|
||||
id: 587d825b367417b2b2512c8b
|
||||
title: Remove an Element from a Max Heap
|
||||
localeTitle: Eliminar un elemento de un montón máximo
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Eliminar un elemento de un montón máximo
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Ahora que podemos agregar elementos a nuestro montón, veamos cómo podemos eliminar elementos. Eliminar e insertar elementos requiere una lógica similar. En un montón máximo, normalmente querrá eliminar el mayor valor, por lo que esto implica simplemente extraerlo de la raíz de nuestro árbol. Esto romperá la propiedad del montón de nuestro árbol, por lo que debemos restablecerla de alguna manera. Normalmente, para un montón máximo, esto se hace de la siguiente manera:
|
||||
Mueva el último elemento del montón a la posición raíz.
|
||||
Si cualquiera de los hijos de la raíz es mayor, intercambie la raíz con el hijo de mayor valor.
|
||||
Continúa intercambiando hasta que el padre sea mayor que ambos hijos o hasta que alcances el último nivel en el árbol.
|
||||
Instrucciones: Agregue un método a nuestro montón máximo llamado eliminar. Este método debe devolver el mayor valor que se ha agregado a nuestro montón máximo y eliminarlo del montón. También debe reordenar el montón para que se mantenga la propiedad de montón. Después de eliminar un elemento, el siguiente elemento más grande que quede en el montón debe convertirse en la raíz. Agregue su método de inserción de nuevo aquí también.
|
||||
</section>
|
||||
<section id="description"> Ahora que podemos agregar elementos a nuestro montón, veamos cómo podemos eliminar elementos. Eliminar e insertar elementos requiere una lógica similar. En un montón máximo, normalmente querrá eliminar el mayor valor, por lo que esto implica simplemente extraerlo de la raíz de nuestro árbol. Esto romperá la propiedad del montón de nuestro árbol, por lo que debemos restablecerla de alguna manera. Normalmente, para un montón máximo, esto se hace de la siguiente manera: Mueva el último elemento del montón a la posición raíz. Si cualquiera de los hijos de la raíz es mayor, intercambie la raíz con el hijo de mayor valor. Continúa intercambiando hasta que el padre sea mayor que ambos hijos o hasta que alcances el último nivel del árbol. Instrucciones: Agregue un método a nuestro montón máximo llamado eliminar. Este método debe devolver el mayor valor que se ha agregado a nuestro montón máximo y eliminarlo del montón. También debe reordenar el montón para que se mantenga la propiedad de montón. Después de eliminar un elemento, el siguiente elemento más grande que quede en el montón debe convertirse en la raíz. Agregue su método de inserción de nuevo aquí también. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -49,6 +43,7 @@ var MaxHeap = function() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 587d8251367417b2b2512c65
|
||||
title: Remove Elements from a Linked List by Index
|
||||
localeTitle: Eliminar elementos de una lista enlazada por índice
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Eliminar elementos de una lista enlazada por índice
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Antes de pasar a otra estructura de datos, obtengamos un par de los últimos bits de práctica con listas vinculadas.
|
||||
Escribamos un método <code>removeAt</code> que elimine el <code>element</code> en un <code>index</code> dado. El método debe llamarse <code>removeAt(index)</code> . Para eliminar un <code>element</code> en un determinado <code>index</code> , deberemos mantener un recuento de cada nodo a medida que avanzamos a lo largo de la lista vinculada.
|
||||
Una técnica común utilizada para recorrer los elementos de una lista enlazada involucra a un <dfn>'corredor'</dfn> , o centinela, que 'apunta' a los nodos que su código está comparando. En nuestro caso, a partir de la <code>head</code> de nuestra lista, comenzamos con una <code>currentIndex</code> variable que comienza en <code>0</code> . El <code>currentIndex</code> debe incrementarse en uno para cada nodo que pasemos.
|
||||
Al igual que con nuestro método <code>remove(element)</code> , debemos tener cuidado de no dejar huérfano al resto de nuestra lista cuando eliminamos el nodo en nuestro método removeAt (índice). Mantenemos nuestros nodos contiguos asegurándonos de que el nodo que tiene referencia al nodo eliminado tenga una referencia al siguiente nodo.
|
||||
</section>
|
||||
<section id="description"> Antes de pasar a otra estructura de datos, obtengamos un par de los últimos bits de práctica con listas vinculadas. Escribamos un método <code>removeAt</code> que elimine el <code>element</code> en un <code>index</code> dado. El método debe llamarse <code>removeAt(index)</code> . Para eliminar un <code>element</code> en un determinado <code>index</code> , deberemos mantener un recuento de cada nodo a medida que avanzamos a lo largo de la lista vinculada. Una técnica común utilizada para recorrer los elementos de una lista enlazada implica un <dfn>'corredor'</dfn> , o centinela, que 'apunta' a los nodos que su código está comparando. En nuestro caso, a partir de la <code>head</code> de nuestra lista, comenzamos con una <code>currentIndex</code> variable que comienza en <code>0</code> . El <code>currentIndex</code> debe incrementarse en uno para cada nodo que pasemos. Al igual que con nuestro método <code>remove(element)</code> , debemos tener cuidado de no dejar huérfano al resto de nuestra lista cuando eliminamos el nodo en nuestro método removeAt (índice). Mantenemos nuestros nodos contiguos asegurándonos de que el nodo que tiene referencia al nodo eliminado tenga una referencia al siguiente nodo. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Escriba un <code>removeAt(index)</code> que elimine y devuelva un nodo a un <code>index</code> determinado. El método debe devolver <code>null</code> si el <code>index</code> dado es negativo, o mayor o igual a la <code>length</code> de la lista enlazada.
|
||||
Nota
|
||||
Recuerde mantener la cuenta del <code>currentIndex</code> .
|
||||
</section>
|
||||
<section id="instructions"> Escriba un <code>removeAt(index)</code> que elimine y devuelva un nodo en un <code>index</code> determinado. El método debe devolver <code>null</code> si el <code>index</code> dado es negativo, o mayor o igual a la <code>length</code> de la lista enlazada. Nota Recuerde mantener la cuenta del <code>currentIndex</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@ -31,7 +23,7 @@ tests:
|
||||
testString: 'assert((function(){var test = new LinkedList(); test.add("cat"); test.add("dog"); test.add("kitten"); test.removeAt(1); return test.size() === 2}()), "Your <code>removeAt</code> method should reduce the <code>length</code> of the linked list");'
|
||||
- text: El método <code>removeAt</code> también debe devolver el elemento del nodo eliminado.
|
||||
testString: 'assert((function(){var test = new LinkedList(); test.add("cat"); test.add("dog"); test.add("kitten"); return test.removeAt(1) === "dog"}()), "Your <code>removeAt</code> method should also return the element of the removed node.");'
|
||||
- text: El método <code>removeAt</code> también debe devolver <code>null</code> si el índice dado es menor que <code>0</code>
|
||||
- text: El método <code>removeAt</code> también debe devolver un <code>null</code> si el índice dado es menor que <code>0</code>
|
||||
testString: 'assert((function(){var test = new LinkedList(); test.add("cat"); test.add("dog"); test.add("kitten"); return (test.removeAt(-1) === null)}()), "Your <code>removeAt</code> method should also return <code>null</code> if the given index is less than <code>0</code>");'
|
||||
- text: El método <code>removeAt</code> también debe devolver un <code>null</code> si el índice dado es igual o mayor que la <code>length</code> de la lista enlazada.
|
||||
testString: 'assert((function(){var test = new LinkedList(); test.add("cat"); test.add("dog"); test.add("kitten"); return (test.removeAt(3) === null)}()), "Your <code>removeAt</code> method should also return <code>null</code> if the given index is equal or more than the <code>length</code> of the linked list.");'
|
||||
@ -101,6 +93,7 @@ function LinkedList() {
|
||||
|
||||
// Only change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 587d8251367417b2b2512c63
|
||||
title: Remove Elements from a Linked List
|
||||
localeTitle: Eliminar elementos de una lista enlazada
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Eliminar elementos de una lista enlazada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
El siguiente método importante que necesitará cualquier implementación de una lista vinculada es un método de <code>remove</code> . Este método debe tomar el elemento que queremos eliminar como argumento y luego buscar en la lista para encontrar y eliminar el nodo que contiene ese elemento.
|
||||
Siempre que eliminemos un nodo de una lista vinculada, es importante que no dejemos huérfanos accidentalmente al hacerlo. Recuerde que la <code>next</code> propiedad de cada nodo apunta al nodo que lo sigue en la lista. Si estamos eliminando el elemento medio, por ejemplo, vamos a querer asegurarse de que tenemos una conexión desde previa del nodo de ese elemento <code>next</code> propiedad para el elemento medio <code>next</code> propiedad (que es el siguiente nodo en la lista!)
|
||||
Esto podría suena realmente confuso, así que volvamos al ejemplo de la línea de conga para tener un buen modelo conceptual. Imagínate a ti mismo en una línea de conga, y la persona que está directamente delante de ti deja la línea. La persona que acaba de dejar la línea ya no tiene a sus manos sobre nadie, y usted ya no tiene las manos sobre la persona que se fue. Da un paso adelante y pone sus manos sobre la siguiente persona que ve.
|
||||
Si el elemento que queremos eliminar es el elemento <code>head</code> , reasignamos la <code>head</code> al segundo nodo de la lista enlazada.
|
||||
</section>
|
||||
<section id="description"> El siguiente método importante que necesitará cualquier implementación de una lista vinculada es un método de <code>remove</code> . Este método debe tomar el elemento que queremos eliminar como argumento y luego buscar en la lista para encontrar y eliminar el nodo que contiene ese elemento. Cada vez que eliminamos un nodo de una lista vinculada, es importante que no dejemos huérfanos accidentalmente al hacerlo. Recuerde que la <code>next</code> propiedad de cada nodo apunta al nodo que lo sigue en la lista. Si estamos eliminando el elemento medio, por ejemplo, vamos a querer asegurarse de que tenemos una conexión desde previa del nodo de ese elemento <code>next</code> propiedad para el elemento medio <code>next</code> propiedad (que es el siguiente nodo en la lista!) Esto puede sonar realmente confuso, así que volvamos al ejemplo de la línea de conga para tener un buen modelo conceptual. Imagínate a ti mismo en una línea de conga, y la persona que está directamente delante de ti deja la línea. La persona que acaba de dejar la línea ya no tiene a sus manos sobre nadie, y usted ya no tiene las manos sobre la persona que se fue. Da un paso adelante y pone sus manos sobre la siguiente persona que ve. Si el elemento que queremos eliminar es el elemento <code>head</code> , reasignamos la <code>head</code> al segundo nodo de la lista enlazada. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Escriba un método de <code>remove</code> que tome un elemento y lo elimine de la lista vinculada.
|
||||
Nota
|
||||
La <code>length</code> de la lista debe disminuir en uno cada vez que se elimine un elemento de la lista vinculada.
|
||||
</section>
|
||||
<section id="instructions"> Escriba un método de <code>remove</code> que toma un elemento y lo elimina de la lista vinculada. Nota La <code>length</code> de la lista debería disminuir en uno cada vez que se elimine un elemento de la lista vinculada. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@ -84,6 +76,7 @@ function LinkedList() {
|
||||
// Only change code above this line
|
||||
};
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -95,67 +88,7 @@ function LinkedList() {
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
class Node {
|
||||
constructor (element) {
|
||||
this.element = element;
|
||||
this.next = null;
|
||||
}
|
||||
}
|
||||
|
||||
class LinkedList {
|
||||
constructor () {
|
||||
this._length = 0;
|
||||
this._head = null;
|
||||
}
|
||||
|
||||
head () {
|
||||
return this._head;
|
||||
}
|
||||
|
||||
size () {
|
||||
return this._length;
|
||||
}
|
||||
|
||||
add (element) {
|
||||
const node = new Node(element);
|
||||
|
||||
if (this._head === null) {
|
||||
this._head = node;
|
||||
} else {
|
||||
let current = this._head;
|
||||
|
||||
while (current.next !== null) {
|
||||
current = current.next;
|
||||
}
|
||||
|
||||
current.next = node;
|
||||
}
|
||||
|
||||
++this._length;
|
||||
}
|
||||
|
||||
remove (element) {
|
||||
if (this._head === null) return;
|
||||
|
||||
let previous;
|
||||
let current = this._head;
|
||||
|
||||
while (current.next !== null && current.element !== element) {
|
||||
previous = current;
|
||||
current = current.next;
|
||||
}
|
||||
|
||||
if (previous) {
|
||||
previous.next = current.next;
|
||||
} else {
|
||||
this._head = current.next;
|
||||
}
|
||||
|
||||
--this._length;
|
||||
}
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,18 +1,16 @@
|
||||
---
|
||||
id: 587d8253367417b2b2512c6b
|
||||
title: Remove from a Set
|
||||
localeTitle: Eliminar de un conjunto
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Eliminar de un conjunto
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En este ejercicio vamos a crear una función de borrado para nuestro conjunto. La función debe llamarse <code>this.remove</code> . Esta función debe aceptar un valor y verificar si existe en el conjunto. Si lo hace, elimine ese valor del conjunto y devuelva verdadero. De lo contrario, devuelve falso.
|
||||
</section>
|
||||
<section id="description"> En estos ejercicios vamos a crear una función de borrado para nuestro conjunto. La función debe llamarse <code>this.remove</code> . Esta función debe aceptar un valor y verificar si existe en el conjunto. Si lo hace, elimine ese valor del conjunto y devuelva verdadero. De lo contrario, devuelve falso. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -59,6 +57,7 @@ function Set() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -70,9 +69,7 @@ function Set() {
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function Set() {var collection = []; this.has = function(e){return(collection.indexOf(e) !== -1);};this.values = function() {return collection;};this.add = function(element) {if (!this.has(element)) {collection.push(element);return true;} else {return false;}};this.remove = function(element) {if(this.has(element)) {var i = collection.indexOf(element);collection.splice(i, 1);return true;}return false;};}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,31 +1,23 @@
|
||||
---
|
||||
id: 587d8254367417b2b2512c71
|
||||
title: Remove items from a set in ES6
|
||||
localeTitle: Eliminar elementos de un conjunto en ES6
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Eliminar elementos de un conjunto en ES6
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Practiquemos la eliminación de elementos de un Conjunto ES6 utilizando el método de <code>delete</code> .
|
||||
Primero, cree un conjunto ES6
|
||||
<code>var set = new Set([1,2,3]);</code>
|
||||
Ahora elimine un elemento de su Set con el método de <code>delete</code> .
|
||||
<blockquote>set.delete(1);<br>console.log([...set]) // should return [ 2, 3 ]<blockquote>
|
||||
</section>
|
||||
<section id="description"> Practiquemos la eliminación de elementos de un Conjunto ES6 utilizando el método de <code>delete</code> . En primer lugar, cree un conjunto <code>var set = new Set([1,2,3]);</code> ES6 <code>var set = new Set([1,2,3]);</code> Ahora elimine un elemento de su Set con el método de <code>delete</code> . <blockquote> set.delete (1); <br> console.log ([... set]) // debería devolver [2, 3] <blockquote></blockquote></blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Ahora, cree un conjunto con los enteros 1, 2, 3, 4 y 5.
|
||||
Elimine los valores 2 y 5, y luego devuelva el conjunto.
|
||||
</section>
|
||||
<section id="instructions"> Ahora, cree un conjunto con los enteros 1, 2, 3, 4 y 5. Quite los valores 2 y 5, y luego devuelva el conjunto. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
|
||||
```yml
|
||||
tests:
|
||||
- text: 'Tu Set debe contener los valores 1, 3 y 4'
|
||||
- text: 'Su Set debe contener los valores 1, 3 y 4'
|
||||
testString: 'assert(function(){var test = checkSet(); return test.has(1) && test.has(3) && test.has(4) && test.size === 3}, "Your Set should contain the values 1, 3, & 4");'
|
||||
|
||||
```
|
||||
@ -45,6 +37,7 @@ function checkSet(){
|
||||
//Return the set
|
||||
return set;
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -56,13 +49,7 @@ function checkSet(){
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function checkSet(){
|
||||
var set = new Set([1,2,3,4,5]);
|
||||
set.delete(2);
|
||||
set.delete(5);
|
||||
return set;}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,18 +1,16 @@
|
||||
---
|
||||
id: 587d825a367417b2b2512c88
|
||||
title: Reverse a Doubly Linked List
|
||||
localeTitle: Invertir una lista doblemente vinculada
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Invertir una lista doblemente vinculada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Creemos un método más para nuestra lista doblemente enlazada llamada reversa que invierte la lista en su lugar. Una vez que se ejecuta el método, la cabeza debe apuntar a la cola anterior y la cola debe apuntar a la cabeza anterior. Ahora, si recorremos la lista de principio a fin, deberíamos encontrar los nodos en orden inverso en comparación con la lista original. Intentar revertir una lista vacía debe devolver nulo.
|
||||
</section>
|
||||
<section id="description"> Vamos a crear un método más para nuestra lista de enlace doble llamada reversa que invierte la lista en su lugar. Una vez que se ejecuta el método, la cabeza debe apuntar a la cola anterior y la cola debe apuntar a la cabeza anterior. Ahora, si recorremos la lista de principio a fin, deberíamos encontrar los nodos en orden inverso en comparación con la lista original. Intentar revertir una lista vacía debe devolver nulo. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -26,7 +24,7 @@ tests:
|
||||
testString: 'assert((function() { var test = false; if (typeof DoublyLinkedList !== "undefined") { test = new DoublyLinkedList() }; if (test.add == undefined) { return false; }; return (typeof test.add == "function")})(), "The DoublyLinkedList has a method called add.");'
|
||||
- text: El DoublyLinkedList tiene un método llamado reversa.
|
||||
testString: 'assert((function() { var test = false; if (typeof DoublyLinkedList !== "undefined") { test = new DoublyLinkedList() }; if (test.reverse == undefined) { return false; }; return (typeof test.reverse == "function")})(), "The DoublyLinkedList has a method called reverse.");'
|
||||
- text: Invertir una lista vacía devuelve nulo.
|
||||
- text: 'Si se invierte una lista vacía, se devuelve un valor nulo.'
|
||||
testString: 'assert((function() { var test = false; if (typeof DoublyLinkedList !== "undefined") { test = new DoublyLinkedList() }; return (test.reverse() == null); })(), "Reversing an empty list returns null.");'
|
||||
- text: El método inverso invierte la lista.
|
||||
testString: 'assert((function() { var test = false; if (typeof DoublyLinkedList !== "undefined") { test = new DoublyLinkedList() }; test.add(58); test.add(61); test.add(32); test.reverse(); return (test.print().join("") == "326158"); })(), "The reverse method reverses the list.");'
|
||||
@ -54,6 +52,7 @@ var DoublyLinkedList = function() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
};
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,20 +1,16 @@
|
||||
---
|
||||
id: 587d8251367417b2b2512c64
|
||||
title: Search within a Linked List
|
||||
localeTitle: Buscar dentro de una lista enlazada
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Buscar dentro de una lista enlazada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Agreguemos algunos métodos más útiles a nuestra clase de lista vinculada. ¿No sería útil si pudiéramos decir si nuestra lista estaba vacía o no, al igual que con nuestras clases de <code>Stack</code> y <code>Queue</code> ?
|
||||
También deberíamos poder encontrar elementos específicos en nuestra lista enlazada. ¡Recorrer a través de estructuras de datos es algo con lo que querrás practicar mucho! Vamos a crear un método <code>indexOf</code> que tome un <code>element</code> como un argumento y devuelva el <code>index</code> ese elemento en la lista enlazada. Si el elemento no se encuentra en la lista enlazada, devuelva <code>-1</code> .
|
||||
Implementemos también un método que haga lo contrario: un método <code>elementAt</code> que toma un <code>index</code> como argumento y devuelve el <code>element</code> en el <code>index</code> dado. Si no se encuentra ningún <code>element</code> , devuelva <code>undefined</code> .
|
||||
</section>
|
||||
<section id="description"> Agreguemos algunos métodos más útiles a nuestra clase de lista vinculada. ¿No sería útil si pudiéramos decir si nuestra lista estaba vacía o no, al igual que con nuestras clases de <code>Stack</code> y <code>Queue</code> ? También deberíamos poder encontrar elementos específicos en nuestra lista enlazada. ¡Recorrer a través de estructuras de datos es algo con lo que querrás practicar mucho! Vamos a crear un método <code>indexOf</code> que tome un <code>element</code> como un argumento y devuelva el <code>index</code> ese elemento en la lista enlazada. Si el elemento no se encuentra en la lista enlazada, devuelva <code>-1</code> . También implementemos un método que haga lo contrario: un método <code>elementAt</code> que toma un <code>index</code> como argumento y devuelve el <code>element</code> en el <code>index</code> dado. Si no se encuentra ningún <code>element</code> , devuelva <code>undefined</code> . </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Escriba un método <code>isEmpty</code> que compruebe si la lista enlazada está vacía, un método <code>indexOf</code> que devuelve el <code>index</code> de un elemento determinado y un <code>elementAt</code> que devuelve un <code>element</code> en un <code>index. <code>0</code></code> determinado <code>index. <code>0</code></code> </section>
|
||||
<section id="instructions"> Escriba un método <code>isEmpty</code> que compruebe si la lista enlazada está vacía, un método <code>indexOf</code> que devuelve el <code>index</code> de un elemento dado y un <code>elementAt</code> que devuelve un <code>element</code> en un <code>index.</code> determinado <code>index.</code> </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@ -97,6 +93,7 @@ function LinkedList() {
|
||||
|
||||
// Only change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,18 +1,16 @@
|
||||
---
|
||||
id: 8d1923c8c441eddfaeb5bdef
|
||||
title: Size of the Set
|
||||
localeTitle: Tamaño del set
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Tamaño del set
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
En este ejercicio vamos a crear una función de tamaño para nuestro Conjunto. Esta función debe llamarse <code>this.size</code> y debe devolver el tamaño de la colección.
|
||||
</section>
|
||||
<section id="description"> En este ejercicio vamos a crear una función de tamaño para nuestro Conjunto. Esta función debe llamarse <code>this.size</code> y debe devolver el tamaño de la colección. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -66,6 +64,7 @@ function Set() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -77,9 +76,7 @@ function Set() {
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function Set() {var collection = []; this.has = function(e){return(collection.indexOf(e) !== -1);};this.values = function() {return collection;};this.add = function(element) {if (!this.has(element)) {collection.push(element);return true;} else {return false;}};this.remove = function(element) {if(this.has(element)) {var i = collection.indexOf(element);collection.splice(i, 1);return true;}return false;};this.size = function() {return collection.length;};}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,32 +1,16 @@
|
||||
---
|
||||
id: 587d8253367417b2b2512c6a
|
||||
title: Typed Arrays
|
||||
localeTitle: Matrices mecanografiadas
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Matrices mecanografiadas
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
matrices son objetos de JavaScript que pueden contener muchos elementos diferentes.
|
||||
<code>var complexArr = [1, 5, "2", "Word", {"name": "James"}];</code>
|
||||
Básicamente, lo que sucede en segundo plano es que su navegador le dará automáticamente la cantidad correcta de espacio de memoria para esa matriz. También cambiará según sea necesario si agrega o elimina datos.
|
||||
Sin embargo, en el mundo del alto rendimiento y los diferentes tipos de elementos, a veces debe ser más específico sobre la cantidad de memoria que se asigna a una matriz.
|
||||
<dfn>Arrays tipados</dfn> son la respuesta a este problema. Ahora puede decir cuánta memoria desea asignar a una matriz. A continuación se muestra una descripción básica de los diferentes tipos de arreglos disponibles y el tamaño en bytes para cada elemento de ese arreglo.
|
||||
<table class='table table-striped'><tr><th> Tipo </th><th> Cada tamaño de elemento en bytes. </th></tr><tr><td> <code>Int8Array</code> </td> <td> 1 </td></tr><tr><td> <code>Uint8Array</code> </td> <td> 1 </td></tr><tr><td> <code>Uint8ClampedArray</code> </td> <td> 1 </td></tr><tr><td> <code>Int16Array</code> </td> <td> 2 </td></tr><tr><td> <code>Uint16Array</code> </td> <td> 2 </td></tr><tr><td> <code>Int32Array</code> </td> <td> 4 </td></tr><tr><td> <code>Uint32Array</code> </td> <td> 4 </td></tr><tr><td> <code>Float32Array</code> </td> <td> 4 </td></tr><tr><td> <code>Float64Array</code> </td> <td> 8 </td></tr></table>
|
||||
Hay dos formas de crear este tipo de arreglos. Una forma es crearlo directamente. A continuación se muestra cómo crear un <code>Int16Array</code> 3 longitudes.
|
||||
<blockquote>var i8 = new Int16Array(3);<br>console.log(i8);<br>// Returns [0, 0, 0]</blockquote>
|
||||
También puede crear un <dfn>búfer</dfn> para asignar la cantidad de datos (en bytes) que desea que ocupe la matriz.
|
||||
<strong>Nota</strong> <br> Para crear matrices escritas utilizando buffers, debe asignar el número de bytes para que sea un múltiplo de los bytes enumerados anteriormente.
|
||||
<blockquote>// Create same Int16Array array differently<br>var byteSize = 6; // Needs to be multiple of 2<br>var buffer = new ArrayBuffer(byteSize);<br>var i8View = new Int16Array(buffer);<br>buffer.byteLength; // Returns 6<br>i8View.byteLength; // Returns 6<br>console.log(i8View); // Returns [0, 0, 0]</blockquote>
|
||||
<dfn>Los buffers</dfn> son objetos de propósito general que solo transportan datos. No puedes acceder a ellos normalmente. Para acceder a ellos, primero debe crear una <dfn>vista</dfn> .
|
||||
<blockquote>i8View[0] = 42;<br>console.log(i8View); // Returns [42, 0, 0]</blockquote>
|
||||
<strong>Nota</strong> <br> Los arreglos escritos no tienen algunos de los métodos que tienen los arreglos tradicionales, como <code>.pop()</code> o <code>.push()</code> . Los arreglos <code>Array.isArray()</code> también fallan en <code>Array.isArray()</code> que verifica si algo es un arreglo. Aunque es más simple, esto puede ser una ventaja para que los motores de JavaScript menos sofisticados los implementen.
|
||||
</section>
|
||||
<section id="description"> Las matrices son objetos de JavaScript que pueden contener muchos elementos diferentes. <code>var complexArr = [1, 5, "2", "Word", {"name": "James"}];</code> Básicamente, lo que sucede en segundo plano es que su navegador le dará automáticamente la cantidad correcta de espacio de memoria para esa matriz. También cambiará según sea necesario si agrega o elimina datos. Sin embargo, en el mundo del alto rendimiento y los diferentes tipos de elementos, a veces debe ser más específico sobre la cantidad de memoria que se asigna a una matriz. <dfn>Arrays tipados</dfn> son la respuesta a este problema. Ahora puede decir cuánta memoria desea asignar a una matriz. A continuación se muestra una descripción básica de los diferentes tipos de arreglos disponibles y el tamaño en bytes para cada elemento de ese arreglo. <table class="table table-striped"><tbody><tr><th> Tipo </th><th> Cada tamaño de elemento en bytes. </th></tr><tr><td> <code>Int8Array</code> </td> <td> 1 </td></tr><tr><td> <code>Uint8Array</code> </td> <td> 1 </td></tr><tr><td> <code>Uint8ClampedArray</code> </td> <td> 1 </td></tr><tr><td> <code>Int16Array</code> </td> <td> 2 </td></tr><tr><td> <code>Uint16Array</code> </td> <td> 2 </td></tr><tr><td> <code>Int32Array</code> </td> <td> 4 </td></tr><tr><td> <code>Uint32Array</code> </td> <td> 4 </td></tr><tr><td> <code>Float32Array</code> </td> <td> 4 </td></tr><tr><td> <code>Float64Array</code> </td> <td> 8 </td></tr></tbody></table> Hay dos formas de crear este tipo de arreglos. Una forma es crearlo directamente. A continuación se muestra cómo crear un <code>Int16Array</code> 3 longitudes. <blockquote> var i8 = nuevo Int16Array (3); <br> console.log (i8); <br> // Devoluciones [0, 0, 0] </blockquote> También puede crear un <dfn>búfer</dfn> para asignar la cantidad de datos (en bytes) que desea que ocupe la matriz. <strong>Nota</strong> <br> Para crear matrices escritas utilizando buffers, debe asignar el número de bytes para que sea un múltiplo de los bytes enumerados anteriormente. <blockquote> // Crear la misma matriz Int16Array de manera diferente <br> var byteSize = 6; // Necesita ser múltiplo de 2 <br> var buffer = new ArrayBuffer (byteSize); <br> var i8View = new Int16Array (buffer); <br> buffer.byteLength; // Devoluciones 6 <br> i8View.byteLength; // Devoluciones 6 <br> console.log (i8View); // Devoluciones [0, 0, 0] </blockquote> <dfn>Los amortiguadores</dfn> son objetos de propósito general que solo llevan datos. No puedes acceder a ellos normalmente. Para acceder a ellos, primero debe crear una <dfn>vista</dfn> . <blockquote> i8View [0] = 42; <br> console.log (i8View); // Devoluciones [42, 0, 0] </blockquote> <strong>Nota</strong> <br> Los arreglos escritos no tienen algunos de los métodos que tienen los arreglos tradicionales, como <code>.pop()</code> o <code>.push()</code> . Los arreglos <code>Array.isArray()</code> también fallan en <code>Array.isArray()</code> que verifica si algo es un arreglo. Aunque es más simple, esto puede ser una ventaja para que los motores de JavaScript menos sofisticados los implementen. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
Primero crea un <code>buffer</code> 64 bytes. Luego cree una <code>Int32Array</code> tipo <code>Int32Array</code> con una vista llamada <code>i32View</code> .
|
||||
</section>
|
||||
<section id="instructions"> Primero crea un <code>buffer</code> 64 bytes. Luego, cree una <code>Int32Array</code> tipo <code>Int32Array</code> con una vista llamada <code>i32View</code> . </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@ -52,6 +36,7 @@ tests:
|
||||
```js
|
||||
var buffer;
|
||||
var i32View;
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -63,10 +48,7 @@ var i32View;
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
var buffer = new ArrayBuffer(64);
|
||||
var i32View = new Int32Array(buffer);
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,32 +1,23 @@
|
||||
---
|
||||
id: 587d8255367417b2b2512c72
|
||||
title: Use .has and .size on an ES6 Set
|
||||
localeTitle: Utilice .has y .size en un conjunto ES6
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Utilice .has y .size en un conjunto ES6
|
||||
---
|
||||
|
||||
## 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>
|
||||
<section id="description"> Veamos los métodos .has y .size disponibles en el objeto Set de ES6. En primer lugar, cree un conjunto <code>var set = new Set([1,2,3]);</code> 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 de 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>
|
||||
<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
|
||||
<section id='tests'>
|
||||
|
||||
```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 ]");'
|
||||
|
||||
```
|
||||
@ -48,6 +39,7 @@ function checkSet(arrToBeSet, checkValue){
|
||||
}
|
||||
|
||||
checkSet([ 1, 2, 3], 2); // Should return [ true, 3 ]
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -59,16 +51,7 @@ checkSet([ 1, 2, 3], 2); // Should return [ true, 3 ]
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function checkSet(arrToBeSet, checkValue){
|
||||
var set = new Set(arrToBeSet);
|
||||
var result = [
|
||||
set.has(checkValue),
|
||||
set.size
|
||||
];
|
||||
return result;
|
||||
}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,20 +1,16 @@
|
||||
---
|
||||
id: 587d8258367417b2b2512c7f
|
||||
title: Use Breadth First Search in a Binary Search Tree
|
||||
localeTitle: Utilice la búsqueda en primer lugar en un árbol de búsqueda binario
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Utilice la búsqueda en primer lugar en un árbol de búsqueda binario
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Aquí vamos a introducir otro método de recorrido de árboles: búsqueda de amplitud en primer lugar. En contraste con los métodos de búsqueda de profundidad primero del último desafío, la búsqueda de amplitud primero explora todos los nodos en un nivel dado dentro de un árbol antes de continuar al siguiente nivel. Normalmente, las colas se utilizan como estructuras de datos auxiliares en el diseño de los algoritmos de búsqueda más avanzados.
|
||||
En este método, comenzamos agregando el nodo raíz a una cola. Luego comenzamos un ciclo en el que sacamos de la cola el primer elemento de la cola, lo agregamos a una nueva matriz y luego inspeccionamos ambos subárboles secundarios. Si sus hijos no son nulos, se ponen en cola. Este proceso continúa hasta que la cola está vacía.
|
||||
Instrucciones: Vamos a crear un primer método de búsqueda en nuestro árbol llamado <code>levelOrder</code> . Este método debe devolver una matriz que contenga los valores de todos los nodos de árbol, explorados de manera integral. Asegúrese de devolver los valores de la matriz, no los nodos en sí. Un nivel debe ser recorrido de izquierda a derecha. A continuación, escribamos un método similar llamado <code>reverseLevelOrder</code> que realiza la misma búsqueda pero en la dirección inversa (de derecha a izquierda) en cada nivel.
|
||||
</section>
|
||||
<section id="description"> Aquí introduciremos otro método de recorrido de árboles: la búsqueda de amplitud en primer lugar. En contraste con los métodos de búsqueda de profundidad primero del último desafío, la búsqueda de amplitud primero explora todos los nodos en un nivel dado dentro de un árbol antes de continuar al siguiente nivel. Normalmente, las colas se utilizan como estructuras de datos auxiliares en el diseño de los algoritmos de búsqueda más avanzados. En este método, comenzamos agregando el nodo raíz a una cola. Luego comenzamos un ciclo en el que sacamos de la cola el primer elemento de la cola, lo agregamos a una nueva matriz y luego inspeccionamos ambos subárboles secundarios. Si sus hijos no son nulos, se ponen en cola. Este proceso continúa hasta que la cola está vacía. Instrucciones: Vamos a crear un primer método de búsqueda en nuestro árbol llamado <code>levelOrder</code> . Este método debe devolver una matriz que contenga los valores de todos los nodos de árbol, explorados de manera integral. Asegúrese de devolver los valores de la matriz, no los nodos en sí. Un nivel debe ser recorrido de izquierda a derecha. A continuación, escribamos un método similar llamado <code>reverseLevelOrder</code> que realiza la misma búsqueda pero en la dirección inversa (de derecha a izquierda) en cada nivel. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -58,6 +54,7 @@ function BinarySearchTree() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,24 +1,16 @@
|
||||
---
|
||||
id: 587d8257367417b2b2512c7e
|
||||
title: Use Depth First Search in a Binary Search Tree
|
||||
localeTitle: Utilice la búsqueda en profundidad primero en un árbol de búsqueda binario
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Utilice la búsqueda en profundidad primero en un árbol de búsqueda binario
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Sabemos cómo buscar un árbol de búsqueda binario para un valor específico. Pero ¿y si solo queremos explorar todo el árbol? ¿O qué sucede si no tenemos un árbol ordenado y solo necesitamos buscar un valor? Aquí introduciremos algunos métodos de recorrido de árboles que se pueden usar para explorar estructuras de datos de árboles. Lo primero es buscar primero en profundidad. En la búsqueda en profundidad, un subárbol determinado se explora lo más profundamente posible antes de que la búsqueda continúe en otro subárbol. Hay tres formas de hacerlo:
|
||||
En orden: comience la búsqueda en el nodo más a la izquierda y finalice en el nodo más a la derecha.
|
||||
Pre-orden: Explorar todas las raíces antes de las hojas.
|
||||
Orden posterior: Explorar todas las hojas antes de las raíces.
|
||||
Como puede suponer, puede elegir diferentes métodos de búsqueda según el tipo de datos que su árbol esté almacenando y lo que está buscando. Para un árbol de búsqueda binario, un recorrido inorder devuelve los nodos en orden ordenado.
|
||||
Instrucciones: Aquí crearemos estos tres métodos de búsqueda en nuestro árbol de búsqueda binario. La búsqueda en profundidad es una operación intrínsecamente recursiva que continúa explorando más subárboles mientras haya nodos secundarios presentes. Una vez que entienda este concepto básico, puede simplemente reorganizar el orden en el que explora los nodos y subárboles para producir cualquiera de las tres búsquedas anteriores. Por ejemplo, en la búsqueda posterior al pedido querríamos repetir todo el camino a un nodo hoja antes de que comencemos a devolver cualquiera de los nodos, mientras que en la búsqueda previa al pedido deseamos devolver primero los nodos y luego continuar recurriendo abajo del arbol
|
||||
Defina los métodos <code>inorder</code> , <code>preorder</code> y <code>postorder</code> en nuestro árbol. Cada uno de estos métodos debe devolver una matriz de elementos que representan el recorrido del árbol. Asegúrese de devolver los valores enteros en cada nodo de la matriz, no los nodos en sí. Finalmente, devuelve <code>null</code> si el árbol está vacío.
|
||||
</section>
|
||||
<section id="description"> Sabemos cómo buscar un árbol de búsqueda binario para un valor específico. Pero ¿y si solo queremos explorar todo el árbol? ¿O qué sucede si no tenemos un árbol ordenado y solo necesitamos buscar un valor? Aquí introduciremos algunos métodos de recorrido de árboles que se pueden usar para explorar estructuras de datos de árboles. Lo primero es buscar primero en profundidad. En la búsqueda en profundidad, un subárbol determinado se explora lo más profundamente posible antes de que la búsqueda continúe en otro subárbol. Hay tres formas de hacer esto: En orden: Comience la búsqueda en el nodo más a la izquierda y finalice en el nodo más a la derecha. Pre-orden: Explorar todas las raíces antes de las hojas. Orden posterior: Explorar todas las hojas antes de las raíces. Como puede suponer, puede elegir diferentes métodos de búsqueda según el tipo de datos que su árbol esté almacenando y lo que está buscando. Para un árbol de búsqueda binario, un recorrido inorder devuelve los nodos en orden ordenado. Instrucciones: Aquí crearemos estos tres métodos de búsqueda en nuestro árbol de búsqueda binario. La búsqueda en profundidad es una operación intrínsecamente recursiva que continúa explorando más subárboles mientras haya nodos secundarios presentes. Una vez que entienda este concepto básico, puede simplemente reorganizar el orden en el que explora los nodos y subárboles para producir cualquiera de las tres búsquedas anteriores. Por ejemplo, en la búsqueda posterior al pedido querríamos repetir todo el camino a un nodo hoja antes de que comencemos a devolver cualquiera de los nodos, mientras que en la búsqueda previa al pedido deseamos devolver primero los nodos y luego continuar recurriendo abajo del arbol Defina los métodos <code>inorder</code> , <code>preorder</code> y <code>postorder</code> en nuestro árbol. Cada uno de estos métodos debe devolver una matriz de elementos que representan el recorrido del árbol. Asegúrese de devolver los valores enteros en cada nodo de la matriz, no los nodos en sí. Finalmente, devuelve <code>null</code> si el árbol está vacío. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
|
||||
<section id="instructions">
|
||||
</section>
|
||||
|
||||
## Tests
|
||||
@ -68,6 +60,7 @@ function BinarySearchTree() {
|
||||
// change code below this line
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
@ -1,23 +1,16 @@
|
||||
---
|
||||
id: 587d8255367417b2b2512c73
|
||||
title: Use Spread and Notes for ES5 Set() Integration
|
||||
localeTitle: Use Spread and Notes para la integración de ES5 Set ()
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Use Spread and Notes para la integración de ES5 Set ()
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
¿Recuerdas el operador de propagación ES6 <code>...</code> ?
|
||||
<code>...</code> puede tomar objetos iterables en ES6 y convertirlos en matrices.
|
||||
Vamos a crear un Set, y echa un vistazo a la función de propagación.
|
||||
<blockquote>var set = new Set([1,2,3]);<br>var setToArr = [...set]<br>console.log(setToArr) // returns [ 1, 2, 3 ]</blockquote>
|
||||
</section>
|
||||
<section id="description"> ¿Recuerdas el operador de propagación ES6 <code>...</code> ? <code>...</code> puede tomar objetos iterables en ES6 y convertirlos en matrices. Vamos a crear un Set, y echa un vistazo a la función de propagación. <blockquote> var set = new Set ([1,2,3]); <br> var setToArr = [... set] <br> console.log (setToArr) // devuelve [1, 2, 3] </blockquote></section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
En este ejercicio pasaremos un objeto establecido a la función <code>checkSet</code> . Debe devolver una matriz que contenga los valores del conjunto.
|
||||
Ahora ha aprendido con éxito cómo usar el objeto <code>Set()</code> ES6, ¡buen trabajo!
|
||||
</section>
|
||||
<section id="instructions"> En este ejercicio pasaremos un objeto establecido a la función <code>checkSet</code> . Debe devolver una matriz que contenga los valores del conjunto. Ahora que aprendió a usar el objeto <code>Set()</code> ES6, ¡buen trabajo! </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@ -42,6 +35,7 @@ function checkSet(set){
|
||||
|
||||
// change code above this line
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
@ -53,10 +47,7 @@ function checkSet(set){
|
||||
## Solution
|
||||
<section id='solution'>
|
||||
|
||||
|
||||
```js
|
||||
function checkSet(set){
|
||||
return [...set];}
|
||||
// solution required
|
||||
```
|
||||
|
||||
</section>
|
||||
|
||||
@ -1,21 +1,16 @@
|
||||
---
|
||||
id: 587d8251367417b2b2512c61
|
||||
title: Work with Nodes in a Linked List
|
||||
localeTitle: Trabajar con nodos en una lista enlazada
|
||||
challengeType: 1
|
||||
videoUrl: ''
|
||||
localeTitle: Trabajar con nodos en una lista enlazada
|
||||
---
|
||||
|
||||
## Description
|
||||
<section id='description'>
|
||||
Otra estructura de datos común con la que se encontrará en informática es la <dfn>lista enlazada</dfn> . Una lista enlazada es una colección lineal de elementos de datos, llamados 'nodos', cada uno de los cuales apunta al siguiente. Cada <dfn>nodo</dfn> en una lista enlazada contiene dos piezas clave de información: el <code>element</code> sí, y una referencia al siguiente <code>node</code> .
|
||||
Imagina que estás en una línea de conga. Tienes las manos en la siguiente persona en la línea, y la persona detrás de ti tiene las manos sobre ti. Puede ver a la persona directamente delante de usted, pero está bloqueando la vista de las otras personas en la fila. Un nodo es como una persona en una línea de conga: saben quiénes son y solo pueden ver a la siguiente persona en la línea, pero no son conscientes de las otras personas que están delante o detrás.
|
||||
</section>
|
||||
<section id="description"> Otra estructura de datos común con la que se encontrará en informática es la <dfn>lista enlazada</dfn> . Una lista enlazada es una colección lineal de elementos de datos, llamados 'nodos', cada uno de los cuales apunta al siguiente. Cada <dfn>nodo</dfn> en una lista enlazada contiene dos piezas clave de información: el <code>element</code> sí, y una referencia al siguiente <code>node</code> . Imagina que estás en una línea de conga. Tienes las manos en la siguiente persona en la línea, y la persona detrás de ti tiene las manos sobre ti. Puede ver a la persona directamente delante de usted, pero está bloqueando la vista de las otras personas en la fila. Un nodo es como una persona en una línea de conga: saben quiénes son y solo pueden ver a la siguiente persona en la línea, pero no son conscientes de las otras personas que están delante o detrás. </section>
|
||||
|
||||
## Instructions
|
||||
<section id='instructions'>
|
||||
En nuestro editor de código, hemos creado dos nodos, <code>Kitten</code> y <code>Puppy</code> , y hemos conectado manualmente el nodo <code>Kitten</code> nodo <code>Puppy</code> .
|
||||
Crea un nodo <code>Cat</code> y <code>Dog</code> y agrégalos manualmente a la línea.
|
||||
</section>
|
||||
<section id="instructions"> En nuestro editor de código, hemos creado dos nodos, <code>Kitten</code> y <code>Puppy</code> , y hemos conectado manualmente el nodo <code>Kitten</code> nodo <code>Puppy</code> . Crea un nodo <code>Cat</code> y <code>Dog</code> y agrégalos manualmente a la línea. </section>
|
||||
|
||||
## Tests
|
||||
<section id='tests'>
|
||||
@ -49,6 +44,7 @@ Kitten.next = Puppy;
|
||||
|
||||
// test your code
|
||||
console.log(Kitten.next);
|
||||
|
||||
```
|
||||
|
||||
</div>
|
||||
|
||||
Reference in New Issue
Block a user