├── .gitignore ├── DS.js ├── README.md ├── checkpoint.js ├── img └── 1.jpg ├── package.json └── tests └── test.spec.js /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | package-lock.json -------------------------------------------------------------------------------- /DS.js: -------------------------------------------------------------------------------- 1 | function Queue() { 2 | this._arr = []; 3 | } 4 | 5 | Queue.prototype.enqueue = function(val) { 6 | this._arr.push(val); 7 | } 8 | 9 | Queue.prototype.dequeue = function() { 10 | return this._arr.shift(); 11 | } 12 | 13 | Queue.prototype.size = function() { 14 | return this._arr.length; 15 | } 16 | 17 | function LinkedList() { 18 | this._length = 0; 19 | this.head = null; 20 | } 21 | 22 | function Node(value){ 23 | this.value = value; 24 | this.next = null; 25 | } 26 | 27 | LinkedList.prototype.add = function(value) { 28 | // Si el head no apuntara a nada (lista vacia) 29 | if (!this.head) { 30 | // Hago que el head apunte al nuevo nodo 31 | this.head = new Node(value); 32 | // retorno el nuevo largo 33 | return ++this._length; 34 | } 35 | // Si el head si apuntara a un nodo 36 | // Creo un cursor con el que recorrer la lista 37 | let cursor = this.head; 38 | // Mientras el cursor este apuntando a alguien 39 | while (cursor.next) { 40 | // Muevo el cursor al nodo apuntado 41 | cursor = cursor.next; 42 | } 43 | // Ahora que el cursor no apunta a otro nodo 44 | // Hago que el nodo del cursor apunte al nuevo nodo 45 | cursor.next = new Node(value); 46 | // retorno el nuevo largo 47 | return ++this._length; 48 | } 49 | 50 | LinkedList.prototype.remove = function(value) { 51 | // Si el head no apuntara a nada (lista vacia) retorno null 52 | if (!this.head) return null; 53 | // Si el head apuntara a un unico nodo 54 | if (!this.head.next) { 55 | // Me guardo ese unico nodo 56 | let unicoNodo = this.head; 57 | // Corto la conexion 58 | this.head = null 59 | // Bajo en 1 '_length' 60 | this._length--; 61 | // Y retorno el valor de ese unico nodo 62 | return unicoNodo.value; 63 | } 64 | // Si hubiera mas nodos 65 | // Creo un cursor con el que recorrer la lista 66 | let cursor = this.head; 67 | // Hasta encontrar el ante ultimo nodo 68 | while (cursor.next.next) { 69 | // Muevo el cursor al nodo apuntado 70 | cursor = cursor.next; 71 | } 72 | // Ahora que el cursor esta en el nodo ante ultimo 73 | // Me guardo el ultimo nodo 74 | let ultimoNodo = cursor.next; 75 | // y desconecto el ante ultimo nodo 76 | cursor.next = null; 77 | // Bajo en 1 '_length' 78 | this._length--; 79 | // y retorno el valor del que era el ultimo nodo 80 | return ultimoNodo.value; 81 | } 82 | 83 | LinkedList.prototype.search = function(check) { 84 | // Si el filtro fuera una funcion llamo a filter 85 | if (check instanceof Function) return this.filter(check); 86 | // Declaro un puntero que apunta al head 87 | let pointer = this.head; 88 | // Mientras el puntero apunte a algo 89 | while (pointer) { 90 | // Compruebo el filtro 91 | if (check === pointer.value) return pointer.value; 92 | // Si no se cumplieron los filtros paso al siguiente nodo 93 | pointer = pointer.next; 94 | } 95 | // Si ya recorri todos nodos retorno null 96 | return null; 97 | } 98 | 99 | LinkedList.prototype.filter = function(check) { 100 | // Declaro un puntero que apunta al head 101 | let pointer = this.head; 102 | // Mientras el puntero apunte a algo 103 | while (pointer) { 104 | // Compruebo el filtro 105 | if (check(pointer.value)) return pointer.value; 106 | // Si no se cumplieron los filtros paso al siguiente nodo 107 | pointer = pointer.next; 108 | } 109 | // Si ya recorri todos nodos retorno null 110 | return null; 111 | } 112 | 113 | function BinarySearchTree(value) { 114 | this.value = value; 115 | this.left = null; 116 | this.right = null; 117 | }; 118 | 119 | BinarySearchTree.prototype.size = function () { 120 | // Declaro una variable que acumula el tamaño 121 | var ret = 1; 122 | // Si existiera izquierda le sumo su tamaño 123 | if (this.left) ret += this.left.size(); 124 | // Si existiera derecha le sumo su tamaño 125 | if (this.right) ret += this.right.size(); 126 | // retorno el tamaño 127 | return ret; 128 | }; 129 | 130 | BinarySearchTree.prototype.insert = function (value) { 131 | // Si el valor del arbol acutal es mayor que el valor a ingresar voy a la izquerda 132 | if (this.value > value) { 133 | // Y no existe un arbol a la izquierda 134 | if (!this.left) { 135 | // Agrego ahi un nuevo arbol que el valor a ingresar 136 | this.left = new BinarySearchTree(value); 137 | } else { 138 | // Pero si existiera un arbol a la izquierda 139 | // Inserto el valor en ese arbol ese (recursion) 140 | this.left.insert(value); 141 | } 142 | } else { 143 | // Pero si el valor es menor o igual que el valor a ingresar 144 | // Y no existe un arbol a la derecha 145 | if (!this.right) { 146 | // Agrego ahi un nuevo arbol com el valor a ingresar 147 | this.right = new BinarySearchTree(value); 148 | } else { 149 | // Pero si existiera un arbol a la derecha 150 | // Inserto el valor en ese arbol (recursion) 151 | this.right.insert(value); 152 | } 153 | } 154 | }; 155 | 156 | BinarySearchTree.prototype.contains = function(checkValue) { 157 | // Si el valor del nodo actual es igual que el valor buscado retorno true 158 | if (this.value === checkValue) return true; 159 | // Si el valor del nodo actual es mayor que el valor buscado 160 | // Y existe un nodo a la izquierda 161 | // recursiono en la izquierda 162 | if (this.value > checkValue && this.left) return this.left.contains(checkValue); 163 | // Si el valor del nodo actual es menor que el valor buscado 164 | // Y existe un nodo a la derecha 165 | // recursiono en la derecha 166 | if ( this.value < checkValue && this.right) return this.right.contains(checkValue); 167 | // Si no quiere decir que termino la busqueda y retorno false 168 | return false 169 | } 170 | 171 | BinarySearchTree.prototype.depthFirstForEach = function(cb, order) { 172 | if (order === "in-order" || !order) { 173 | // in-order => left -> actual -> right 174 | // Si existiera left recursiono en left 175 | if (this.left) this.left.depthFirstForEach(cb, order); 176 | // Llamo al callback con el valor actual 177 | cb(this.value); 178 | // Si existiera right recursiono en right 179 | if (this.right) this.right.depthFirstForEach(cb, order); 180 | } else if (order === "pre-order") { 181 | // pre-order => actual -> left -> right 182 | // Llamo al callback con el valor actual 183 | cb(this.value); 184 | // Si existiera left recursiono en left 185 | if (this.left) this.left.depthFirstForEach(cb, order); 186 | // Si existiera right recursiono en right 187 | if (this.right) this.right.depthFirstForEach(cb, order); 188 | } else if (order === "post-order") { 189 | // post-order => left -> right -> actual 190 | // Si existiera left recursiono en left 191 | if (this.left) this.left.depthFirstForEach(cb, order); 192 | // Si existiera right recursiono en right 193 | if (this.right) this.right.depthFirstForEach(cb, order); 194 | // Llamo al callback con el valor actual 195 | cb(this.value); 196 | } 197 | } 198 | 199 | BinarySearchTree.prototype.breadthFirstForEach = function(cb) { 200 | // Declaro un for que inicialice un array con this 201 | // mientras el largo del mismo sea mayor a cero 202 | // Voy quitando el primer elemento del array 203 | // De esta manera cada arbol recorrido va agregando sus subarboles a la ejecucion del for 204 | for (var pointers = [this]; pointers.length > 0; pointers.shift()) { 205 | // Llamo al callback con el valor de cada puntero 206 | cb(pointers[0].value); 207 | // Y si tubiera derecha o izquierda lo agrego al array 208 | if(pointers[0].left) pointers.push(pointers[0].left) 209 | if(pointers[0].right) pointers.push(pointers[0].right) 210 | } 211 | } 212 | 213 | module.exports = { 214 | Queue, 215 | Node, 216 | LinkedList, 217 | BinarySearchTree 218 | }; -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Fake Javascript Checkpoint 2 | ![myimage-alt-tag](./img/1.jpg) 3 | 4 | _Estos son ejercicios para la práctica del M1 JavaScript. Nuestro principal objetivo es que lleguen SUPER preparados y confiados a este Checkpoint_ 5 | _No se frustren si no pueden con tal o cual ejercicio porque está pensado para ser más exigente que el Checkpoint original!_ 6 | 7 | ## Configuración inicial 🚀 8 | - Ejecutar `npm Install` desde la carpeta challenge-javascript, para instalar las dependencias necesarias para correr los test 9 | 10 | ## 📋 Instrucciones 11 | - Completar el archivo `checkpoint.js` de la misma carpeta 12 | - Correr los test con el comando `npm test` 13 | 14 | ### Notas al pie: 15 | - Tener en cuenta que puede que los ejercicios no estén ordenados progresivamente por dificultad, así que si te trabas mucho con uno proba pasar al siguiente para mejor suerte! 16 | - ☕️ Tomarse los descansos necesarios! 17 | - Es importante ir tomándose breves descansos de 10 a 20min para descansar la mente y ordenar las ideas 18 | 19 | 20 | --- 21 | Hecho con ❤️ por Javi y Ailu 😊 -------------------------------------------------------------------------------- /checkpoint.js: -------------------------------------------------------------------------------- 1 | // ----- IMPORTANTE ----- 2 | 3 | // IMPORTANTE!: Para este checkpoint se les brindarán las 4 | // implementaciones ya realizadas en las homeworks de 5 | // Queue, LinkedList y BinarySearchTree. 6 | // Sobre dichas implementaciónes van a tener que agregar nuevos 7 | // métodos o construir determinadas funciones explicados más abajo. 8 | // Pero todos los métodos ya implementados en las homeowrks no es 9 | // necesario que los vuelvan a definir. 10 | 11 | const { 12 | Queue, 13 | LinkedList, 14 | Node, 15 | BinarySearchTree 16 | } = require('./DS.js'); 17 | 18 | // ----- Closures ----- 19 | 20 | // EJERCICIO 1 21 | // Implementar la funcion 'exponencial' que recibe un parametro entero 'exp' 22 | // y retorna una una funcion, nos referiremos a esta ultima como funcion hija, 23 | // y a 'exponencial' como la funcion padre, la funcion hija debe de recibir 24 | // un parametro y retornar dicho parametro elevado al parametro 'exp' de 25 | // la funcion padre original 'exponencial' 26 | // Ejemplo: 27 | // > var sqrt = exponencial(2); 28 | // > sqrt(2); 29 | // < 4 30 | // > sqrt(3); 31 | // < 9 32 | // > sqrt(4); 33 | // < 16 34 | 35 | function exponencial(exp) { 36 | 37 | } 38 | 39 | // ----- Recursión ----- 40 | 41 | // EJERCICIO 2 42 | // Crear la funcion 'direcciones': 43 | // La funcion debe retornar un string de los movimientos Norte(N), Sur(S), Este(E), Oeste(O) 44 | // que se deben realizar, para llegar al destino de un laberinto dado. 45 | // 46 | // Ejemplo: dado el siguiente laberinto: 47 | // let laberintoExample = { // direccion = "" 48 | // N: 'pared', 49 | // S: { // direccion = "S" 50 | // N: 'pared', 51 | // S: 'pared', 52 | // E: { // direccion = "SE" 53 | // N: 'destino', // direccion = "SEN" 54 | // S: 'pared', 55 | // E: 'pared', 56 | // O: 'pared' 57 | // }, 58 | // O: { // direccion = "SO" 59 | // N: 'pared', 60 | // S: 'pared', 61 | // E: 'pared', 62 | // O: 'pared' 63 | // } 64 | // }, 65 | // E: 'pared', 66 | // O: 'pared' 67 | // } 68 | // El retorno de la funcion 'direcciones' debe ser 'SEN', ya que el destino se encuentra 69 | // haciendo los movimientos SUR->ESTE->NORTE 70 | // Aclaraciones: el segundo parametro que recibe la funcion ('direccion') puede ser pasado vacio (null) 71 | 72 | function direcciones(laberinto) { 73 | 74 | } 75 | 76 | 77 | // EJERCICIO 3 78 | // Crea la funcion 'deepEqualArrays': 79 | // Dado que las comparaciones en javascript aveces son un problema como con el siguiente ejemplo: 80 | // [0,1,2] === [0,1,2] => false // puede probarlo en la consola 81 | // con objetos o arrays identicos surge la necesidad de comparar en 'profundidad' arrays u objetos 82 | // en este caso la funcion solo va a ser pensada para recibir arrays, 83 | // pero estos pueden tener multiples niveles de anidacion, y la funcion deepEqualArrays debe 84 | // comparar cada elemento, sin importar la profundidad en la que este 85 | // Ejemplos: 86 | // deepEqualArrays([0,1,2], [0,1,2]) => true 87 | // deepEqualArrays([0,1,2], [0,1,2,3]) => false 88 | // deepEqualArrays([0,1,[[0,1,2],1,2]], [0,1,[[0,1,2],1,2]]) => true 89 | 90 | function deepEqualArrays(arr1, arr2) { 91 | 92 | } 93 | 94 | 95 | 96 | // ----- LinkedList ----- 97 | 98 | // Deben completar la siguiente implementacion 'OrderedLinkedList'(OLL) 99 | // que es muy similar a las LinkedList vistas en clase solo que 100 | // los metodos son distintos y deben de estar pensados para conservar la lista 101 | // ordenada de mayor a menor. 102 | // ejemplos: 103 | // head --> 5 --> 3 --> 2 --> null 104 | // head --> 4 --> 3 --> 1 --> null 105 | // head --> 9 --> 3 --> -1 --> null 106 | // Las dos clases principales ya van a estar implementadas a continuacion: 107 | function OrderedLinkedList() { 108 | this.head = null; 109 | } 110 | // notar que Node esta implementado en el archivo DS 111 | 112 | // Y el metodo print que permite visualizar la lista: 113 | OrderedLinkedList.prototype.print = function(){ 114 | let print = 'head' 115 | let pointer = this.head 116 | while (pointer) { 117 | print += ' --> ' + pointer.value 118 | pointer = pointer.next; 119 | } 120 | print += ' --> null' 121 | return print 122 | } 123 | 124 | 125 | // EJERCICIO 4 126 | // Crea el metodo 'add' que debe agregar nodos a la OLL de forma que la misma se conserve ordenada: 127 | // Ejemplo: 128 | // > LL.print() 129 | // < 'head --> null' 130 | // > LL.add(1) 131 | // > LL.print() 132 | // < 'head --> 1 --> null' 133 | // 2 c 134 | // > LL.add(5) 135 | // > LL.print() 136 | // < 'head --> 5 --> 1 --> null' 137 | // > LL.add(4) 138 | // > LL.print() 139 | // < 'head --> 5 --> 3 --> 1 --> null' 140 | // 4 141 | OrderedLinkedList.prototype.add = function(val){ 142 | 143 | } 144 | 145 | 146 | // EJERCICIO 5 147 | // Crea el metodo 'removeHigher' que deve devolver el valor mas alto de la linked list 148 | // removiendo su nodo corresponidente: 149 | // Ejemplo: 150 | // > LL.print() 151 | // < 'head --> 5 --> 4 --> 1 --> null' 152 | // > LL.removeHigher() 153 | // < 5 154 | // > LL.removeHigher() 155 | // < 4 156 | // > LL.removeHigher() 157 | // < 1 158 | // > LL.removeHigher() 159 | // < null 160 | 161 | OrderedLinkedList.prototype.removeHigher = function(){ 162 | 163 | } 164 | 165 | 166 | // EJERCICIO 6 167 | // Crea el metodo 'removeLower' que deve devolver el valor mas bajo de la linked list 168 | // removiendo su nodo corresponidente: 169 | // Ejemplo: 170 | // > LL.print() 171 | // < 'head --> 5 --> 4 --> 1 --> null' 172 | // > LL.removeHigher() 173 | // < 1 174 | // > LL.removeHigher() 175 | // < 4 176 | // > LL.removeHigher() 177 | // < 5 178 | // > LL.removeHigher() 179 | // < null 180 | 181 | OrderedLinkedList.prototype.removeLower = function(){ 182 | 183 | } 184 | 185 | 186 | 187 | // ----- QUEUE ----- 188 | 189 | // EJERCICIO 7 190 | // Implementar la funcion multiCallbacks: 191 | // la funcion multiCallbacks recibe dos arrays de objetos cuyas propiedades son dos, 192 | // 'cb' que es una funcion, y 'time' que es el tiempo estimado de ejecucion de dicha funcion 193 | // este ultimo representado con un integer como se muestra acontinuacion: 194 | // let cbsExample = [ 195 | // {cb:function(){}, time: 2}, 196 | // {cb:function(){}, time: 3} 197 | // ] 198 | // De manera que lo que nuestra funcion 'multiCallbacks' debe de ir ejecutando las funciones 199 | // sin pasarle parametros pero debe ir alternando las funciones de cbs1 y cbs2 200 | // segun cual de estas se estima que tarde menos, retornando un arreglo de resultados 201 | // de las mismas en el orden que fueron ejecutadas 202 | // Ejemplo: 203 | // > let cbs1 = [ 204 | // {cb:function(){return '1-1'}, time: 2}, 205 | // {cb:function(){return '1-2'}, time: 3} 206 | // ]; 207 | // > let cbs2 = [ 208 | // {cb:function(){return '2-1'}, time: 1}, 209 | // {cb:function(){return '2-2'}, time: 4} 210 | // ]; 211 | // > multiCallbacks(cbs1, cbs2); 212 | // < ["2-1", "1-1", "1-2", "2-2"]; 213 | 214 | function multiCallbacks(cbs1, cbs2){ 215 | 216 | } 217 | 218 | 219 | 220 | // ----- BST ----- 221 | 222 | // EJERCICIO 8 223 | // Implementar el metodo 'toArray' en el prototype del BinarySearchTree 224 | // que devuelva los valores del arbol en una array ordenado 225 | // Ejemplo: 226 | // 32 227 | // / \ 228 | // 8 64 229 | // / \ 230 | // 5 9 231 | // resultado:[5,8,9,32,64] 232 | 233 | BinarySearchTree.prototype.toArray = function() { 234 | 235 | } 236 | 237 | 238 | 239 | // ----- Algoritmos ----- 240 | 241 | // Ejercicio 9 242 | // Implementar la funcion 'primalityTest' que dado un valor numerico entero 243 | // debe de retornar true or false dependiendo de si este es primo o no. 244 | // Puede que este es un algoritmo que ya hayan implementado pero entenderan 245 | // que es un algoritmo que segun la implementacion puede llegar a ser muy costoso 246 | // para numeros demasiado grandes, asi que vamos a implementarlo mediante un metodo 247 | // derivado de Trial Division como el que se muestra aca: 248 | // https://en.wikipedia.org/wiki/Primality_test 249 | // Si bien esta no es la mejor implementacion existente, con que uds puedan 250 | // informarse sobre algoritmos, leerlos de un pseudocodigo e implemnterlos alcanzara 251 | 252 | function primalityTest(n) { 253 | 254 | } 255 | 256 | 257 | // EJERCICIO 10 258 | // Implementa el algoritmo conocido como 'quickSort', que dado un arreglo de elemntos 259 | // retorn el mismo ordenado de 'mayor a menor!' 260 | // https://en.wikipedia.org/wiki/Quicksort 261 | 262 | function quickSort(array) { 263 | 264 | } 265 | // QuickSort ya lo conocen solo que este 266 | // ordena de mayor a menor 267 | // para esto hay que unir como right+mid+left o cambiar el 268 | // signo menor en la comparacion con el pivot 269 | 270 | 271 | 272 | 273 | // ----- EXTRA CREDIT ----- 274 | 275 | // EJERCICIO 11 276 | // Implementa la función 'reverse', que recibe un numero entero como parametro 277 | // e invierte el mismo. 278 | // Pero Debería hacer esto sin convertir el número introducido en una cadena, o un array 279 | // Ejemplo: 280 | // > reverse(123); 281 | // < 321 282 | // > reverse(95823); 283 | // < 32859 284 | 285 | function reverse(num){ 286 | 287 | } 288 | // la grandiosa resolucion de Wilson!!! 289 | // declaran una variable donde 290 | // almacenar el el numero invertido 291 | // y van multiplicando por 10 la 292 | // porcion del numero que ya invirtieron 293 | // deforma que esta se corra hacia la izq 294 | // para agregar el ultimo numero de la 295 | // porcion no revertida 296 | // y luego le quitan a la porcion 297 | // no revertida el ultimo numero 298 | 299 | module.exports = { 300 | exponencial, 301 | direcciones, 302 | deepEqualArrays, 303 | OrderedLinkedList, 304 | multiCallbacks, 305 | primalityTest, 306 | quickSort, 307 | reverse, 308 | Queue, 309 | LinkedList, 310 | Node, 311 | BinarySearchTree 312 | } -------------------------------------------------------------------------------- /img/1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Alonxx/challenge-javascript/06a80202a9d4a0eebda608d5332d0b61d73a02aa/img/1.jpg -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "cp-m1-practice", 3 | "version": "1.0.0", 4 | "description": "just for practice", 5 | "main": "checkpoint.js", 6 | "directories": { 7 | "test": "tests" 8 | }, 9 | "scripts": { 10 | "test": "mocha ./tests/**.js -w" 11 | }, 12 | "author": "JavierBalonga", 13 | "license": "ISC", 14 | "dependencies": { 15 | "chai": "^4.2.0", 16 | "mocha": "^8.2.1" 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /tests/test.spec.js: -------------------------------------------------------------------------------- 1 | ;var expect = require("chai").expect; 2 | 3 | const { 4 | exponencial, 5 | direcciones, 6 | deepEqualArrays, 7 | OrderedLinkedList, 8 | multiCallbacks, 9 | primalityTest, 10 | quickSort, 11 | reverse, 12 | Queue, 13 | LinkedList, 14 | Node, 15 | BinarySearchTree 16 | } = require('../checkpoint'); 17 | 18 | describe('Practica del Checkpoint M1', function(){ 19 | 20 | describe('EJERCICIO 1: exponencial:', function() { 21 | let sqrt = exponencial(2); 22 | let e4 = exponencial(4); 23 | let e3 = exponencial(3); 24 | xit('La funcion hija debe de elevar al cuadrado, si 2 le es pasado como parametro a la funcion padre', function() { 25 | expect(typeof sqrt).to.be.equal('function'); 26 | expect(sqrt(2)).to.be.equal(4); 27 | expect(sqrt(3)).to.be.equal(9); 28 | expect(sqrt(4)).to.be.equal(16); 29 | }); 30 | xit('La funcion hija debe de elevar al cubo, si 3 le es pasado como parametro a la funcion padre', function() { 31 | expect(typeof e3).to.be.equal('function'); 32 | expect(e3(2)).to.be.equal(8); 33 | expect(e3(3)).to.be.equal(27); 34 | expect(e3(4)).to.be.equal(64); 35 | }); 36 | xit('La funcion hija debe de elevar a 4, si 4 le es pasado como parametro a la funcion padre', function() { 37 | expect(typeof e4).to.be.equal('function'); 38 | expect(e4(2)).to.be.equal(16); 39 | expect(e4(3)).to.be.equal(81); 40 | expect(e4(4)).to.be.equal(256); 41 | }); 42 | }) 43 | 44 | describe('EJERCICIO 2: direcciones:', function(){ 45 | let lab1 = { 46 | N: 'pared', S: { 47 | N: 'pared', S: 'pared', E: 'pared', O: { 48 | N: 'pared', S: 'destino', E: 'pared', O: 'pared' 49 | } 50 | }, E: 'pared', O: 'pared' 51 | } 52 | let lab2 = { 53 | N: 'pared', S: 'pared', E: { 54 | N: 'pared', S: { 55 | N: 'pared', S: 'pared', E: 'pared', O: { 56 | N: { 57 | N: 'pared', S: 'pared', E: 'pared', O: { 58 | N: 'pared', S: { 59 | N: 'pared', S: 'pared', E: 'destino', O: 'pared' 60 | }, E: 'pared', O: 'pared' 61 | } 62 | }, S: 'pared', E: 'pared', O: 'pared' 63 | } 64 | }, E: 'pared', O: 'pared' 65 | }, O: 'pared' 66 | } 67 | let lab3 = { 68 | N: 'pared', S: 'pared', E: { 69 | N: 'pared', S: { 70 | N: 'pared', S: 'pared', E: 'pared', O: { 71 | N: 'pared', S: { 72 | N: 'pared', S: 'pared', E: { 73 | N: 'pared', S: 'pared', E: 'destino', O: 'pared' 74 | }, O: 'pared' 75 | }, E: 'pared', O: 'pared' 76 | } 77 | }, E: 'pared', O: 'pared' 78 | }, O: 'pared' 79 | } 80 | xit("Si no se le pasa un laberinto debe retornar ''", function() { 81 | expect(direcciones()).to.be.equal(''); 82 | }); 83 | xit("Si se le pasa un laberinto sin destino debe retornar ''", function() { 84 | expect(direcciones({N:'pared', S:'pared', E:'pared', O:'pared'})).to.be.equal(''); 85 | }); 86 | xit("Debe encontrar el destino dentro del laberinto y retornar los movimientos", function() { 87 | expect(direcciones(lab1)).to.be.equal('SOS'); 88 | expect(direcciones(lab2)).to.be.equal('ESONOSE'); 89 | expect(direcciones(lab3)).to.be.equal('ESOSEE'); 90 | }); 91 | }) 92 | 93 | describe('EJERCICIO 3: deepEqualArrays', function(){ 94 | xit('Debe hacer comparaciones superficiales', function(){ 95 | expect(deepEqualArrays( 96 | [0,1,2], 97 | [0,1,2] 98 | )).to.be.true; 99 | }) 100 | xit('Debe comparar el tipo de cada elemento tambien', function(){ 101 | expect(deepEqualArrays( 102 | [0,1,2], 103 | ['0','1','2'] 104 | )).to.be.false; 105 | }) 106 | xit('Debe comparar todos los elementos de ambos arrays', function(){ 107 | expect(deepEqualArrays( 108 | [0,1,2], 109 | [0,1,2,4] 110 | )).to.be.false; 111 | }) 112 | xit("Debe de hacer comparacion en 'profundidad'", function(){ 113 | expect(deepEqualArrays( 114 | [0,1,[[0,1,2],1,2]], 115 | [0,1,[[0,1,2],1,2]] 116 | )).to.be.true; 117 | }) 118 | }) 119 | 120 | describe("EJERCICIO 4: OrderedLinkedList metodo add", function(){ 121 | let ll = new OrderedLinkedList() 122 | xit("debe agregar nodos a la OrderedLinkedList", function(){ 123 | ll.add(5) 124 | let ll2 = new OrderedLinkedList() 125 | ll2.head = new Node(5) 126 | expect(ll).to.be.deep.equal(ll2) 127 | }) 128 | xit("debe agregar nodos a la OrderedLinkedList, despues de los nodos mayores al argumento", function(){ 129 | ll.add(1) 130 | let ll2 = new OrderedLinkedList() 131 | ll2.head = new Node(5) 132 | ll2.head.next = new Node(1) 133 | expect(ll).to.be.deep.equal(ll2) 134 | }) 135 | xit("debe agregar nodos a la OrderedLinkedList, antes de los nodos menores al argumento", function(){ 136 | ll.add(4) 137 | let ll2 = new OrderedLinkedList() 138 | ll2.head = new Node(5) 139 | ll2.head.next = new Node(4) 140 | ll2.head.next.next = new Node(1) 141 | expect(ll).to.be.deep.equal(ll2) 142 | }) 143 | }) 144 | 145 | describe("EJERCICIO 5: OrderedLinkedList metodo removeHigher", function(){ 146 | xit("debe retirar los nodos mas grandes de la OrderedLinkedList", function(){ 147 | let ll = new OrderedLinkedList() 148 | ll.head = new Node(5) 149 | ll.head.next = new Node(4) 150 | ll.head.next.next = new Node(1) 151 | expect(ll.removeHigher()).to.be.equal(5) 152 | expect(ll.removeHigher()).to.be.equal(4) 153 | expect(ll.removeHigher()).to.be.equal(1) 154 | expect(ll.head).to.be.equal(null) 155 | }) 156 | xit("si la OrderedLinkedList esta vacia debe retornar null", function(){ 157 | let ll = new OrderedLinkedList() 158 | expect(ll.removeHigher()).to.be.equal(null) 159 | expect(ll.removeHigher()).to.be.equal(null) 160 | expect(ll.removeHigher()).to.be.equal(null) 161 | }) 162 | }) 163 | 164 | describe("EJERCICIO 6: OrderedLinkedList metodo removeLower", function(){ 165 | xit("debe retirar los nodos mas chicos de la OrderedLinkedList", function(){ 166 | let ll = new OrderedLinkedList() 167 | ll.head = new Node(5) 168 | ll.head.next = new Node(4) 169 | ll.head.next.next = new Node(1) 170 | expect(ll.removeLower()).to.be.equal(1) 171 | expect(ll.removeLower()).to.be.equal(4) 172 | expect(ll.removeLower()).to.be.equal(5) 173 | expect(ll.head).to.be.equal(null) 174 | }) 175 | xit("si la OrderedLinkedList esta vacia debe retornar null", function(){ 176 | let ll = new OrderedLinkedList() 177 | expect(ll.removeLower()).to.be.equal(null) 178 | expect(ll.removeLower()).to.be.equal(null) 179 | expect(ll.removeLower()).to.be.equal(null) 180 | }) 181 | }) 182 | 183 | describe("EJERCICIO 7: multiCallbacks", function(){ 184 | let arr = [] 185 | const cbs1 = [ 186 | {cb:()=>(arr.push('1-1'),'1-1'), time: 2}, 187 | {cb:()=>(arr.push('1-2'),'1-2'), time: 3} 188 | ]; 189 | const cbs2 = [ 190 | {cb:()=>(arr.push('2-1'),'2-1'), time: 1}, 191 | {cb:()=>(arr.push('2-2'),'2-2'), time: 4} 192 | ]; 193 | xit("todas las funciones(callbacks) deben haber sido llamadas", function(){ 194 | arr = [] 195 | multiCallbacks([...cbs1], [...cbs2]) 196 | expect(arr.length).to.be.equal(4) 197 | }) 198 | xit("las funciones deben haber sido llamadas en el orden correcto", function(){ 199 | arr = [] 200 | multiCallbacks([...cbs1], [...cbs2]) 201 | expect(arr).to.be.deep.equal([ '2-1', '1-1', '1-2', '2-2' ]) 202 | }) 203 | xit("la funcion 'multiCallbacks' debe retornar un array con los resultados en el orden correcto", function(){ 204 | expect(multiCallbacks([...cbs1], [...cbs2])).to.be.deep.equal([ '2-1', '1-1', '1-2', '2-2' ]) 205 | }) 206 | }) 207 | 208 | describe("EJERCICIO 8: BinarySearchTree metodo toArray", function(){ 209 | const BST = new BinarySearchTree(32) 210 | const arr = [8, 64, 5, 9]; 211 | arr.forEach(e => BST.insert(e)) 212 | xit("Debe devolver un Array", function(){ 213 | expect(BST.toArray() instanceof Array).to.be.true; 214 | }) 215 | xit("Debe devolver todos los elementos del arbol", function(){ 216 | expect(BST.toArray() instanceof Array).to.be.true; 217 | expect(BST.toArray().length).to.be.equal(5); 218 | }) 219 | xit("Debe devolver todos los elementos del arbol, en un array ordenado", function(){ 220 | expect(BST.toArray()).to.be.deep.equal([ 5, 8, 9, 32, 64 ]); 221 | }) 222 | }) 223 | 224 | describe("EJERCICIO 9: primalityTest", function(){ 225 | xit("debe de retornar 'true' si el numero es primo", function(){ 226 | expect(primalityTest(2)).to.be.true; 227 | expect(primalityTest(3)).to.be.true; 228 | expect(primalityTest(5)).to.be.true; 229 | expect(primalityTest(7)).to.be.true; 230 | }) 231 | xit("debe de retornar 'false' si el numero NO es primo", function(){ 232 | expect(primalityTest(4)).to.be.false; 233 | expect(primalityTest(6)).to.be.false; 234 | expect(primalityTest(8)).to.be.false; 235 | expect(primalityTest(9)).to.be.false; 236 | }) 237 | xit("debe de retornar 'false' si el numero es menor que 2", function(){ 238 | expect(primalityTest(-1)).to.be.false; 239 | expect(primalityTest(0)).to.be.false; 240 | expect(primalityTest(1)).to.be.false; 241 | }) 242 | xit("debe de estar lo suficientemente optimizado como para tardar menos de 2s con numeros grandes", function(){ 243 | expect(primalityTest(1902680207)).to.be.true; 244 | }) 245 | }) 246 | 247 | describe("EJERCICIO 10: quickSort", function(){ 248 | const arr = [2,5,9,3,4,7,1] 249 | xit("no debe de utilizar el metodo sort", function(){ 250 | expect(quickSort.toString().includes('.sort')).to.be.false; 251 | }) 252 | xit("debe devolver el arreglo ordenado", function(){ 253 | expect(quickSort(arr)).to.be.deep.equal(arr.sort().reverse()) 254 | }) 255 | }) 256 | 257 | describe("EJERCICIO 11: reverse", function(){ 258 | xit("no debe de utilizar arrays o strings ni ninguna estructura identable", function(){ 259 | const forbiddenKeys = ['function','=>','[',']','.toString()','String','stringify','Array','.pop','.push','.shift','.unshift','in'] 260 | const reverseString = reverse.toString().slice(8) 261 | forbiddenKeys.forEach(key => { 262 | expect(reverseString.includes(key)).to.be.false; 263 | }) 264 | }) 265 | xit("debe devolver el numero invertido", function(){ 266 | expect(reverse(123)).to.be.equal(321); 267 | expect(reverse(13543216)).to.be.equal(61234531); 268 | expect(reverse(85498322791)).to.be.equal(19722389458); 269 | expect(reverse(32168448733)).to.be.equal(33784486123); 270 | }) 271 | }) 272 | 273 | }); 274 | --------------------------------------------------------------------------------