10 |
9 |
10 |
14 | 
15 |
54 | Press n or j to go to the next uncovered block, b, p or k for the previous block. 55 |
56 || 1 60 | 2 61 | 3 62 | 4 63 | 5 64 | 6 65 | 7 66 | 8 67 | 9 68 | 10 69 | 11 70 | 12 71 | 13 72 | 14 73 | 15 74 | 16 75 | 17 76 | 18 77 | 19 78 | 20 79 | 21 80 | 22 81 | 23 82 | 24 83 | 25 84 | 26 85 | 27 86 | 28 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 1x 95 | 96 | 4x 97 | 98 | 99 | 100 | 101 | 4x 102 | 4x 103 | 27x 104 | 16x 105 | 106 | 11x 107 | 2x 108 | 109 | 9x 110 | 111 | 2x 112 | 113 | | // Crear un bracket validator,
114 | // que este balanceado correctamente, los brackets validos son los siguientes,
115 |
116 | // '{[],()}' deberia devolver true
117 | // '{[(])}' deberia devolver false
118 | // '{[(' deberia devolver false
119 | // {[([{()[]{}}])]} deberia devolver true
120 |
121 | module.exports = function bracketValidator(cadena) {
122 |
123 | const bracket = {
124 | '{': '}',
125 | '[': ']',
126 | '(': ')'
127 | }
128 | const openBracket = [];
129 | for (var i = 0; i < cadena.length; i++) {
130 | if (bracket[cadena[i]]) {
131 | openBracket.push(cadena[i])
132 | }
133 | else if (bracket[openBracket.pop()] !== cadena[i]) {
134 | return false;
135 | }
136 | else continue;
137 | }
138 | return !openBracket.length;
139 | }
140 | |
54 | Press n or j to go to the next uncovered block, b, p or k for the previous block. 55 |
56 || File | 63 |64 | | Statements | 65 |66 | | Branches | 67 |68 | | Functions | 69 |70 | | Lines | 71 |72 | |
|---|---|---|---|---|---|---|---|---|---|
| bracketValidator.js | 76 |
77 |
78 | |
79 | 100% | 80 |11/11 | 81 |100% | 82 |4/4 | 83 |100% | 84 |1/1 | 85 |100% | 86 |10/10 | 87 |
| indexArray.js | 91 |
92 |
93 | |
94 | 100% | 95 |10/10 | 96 |100% | 97 |4/4 | 98 |100% | 99 |1/1 | 100 |100% | 101 |6/6 | 102 |
| mayorGanancia.js | 106 |
107 |
108 | |
109 | 100% | 110 |10/10 | 111 |100% | 112 |2/2 | 113 |100% | 114 |1/1 | 115 |100% | 116 |8/8 | 117 |
| minStack.js | 121 |
122 |
123 | |
124 | 0% | 125 |0/12 | 126 |0% | 127 |0/8 | 128 |0% | 129 |0/5 | 130 |0% | 131 |0/12 | 132 |
| multidimensionalArray.js | 136 |
137 |
138 | |
139 | 100% | 140 |8/8 | 141 |100% | 142 |2/2 | 143 |100% | 144 |1/1 | 145 |100% | 146 |7/7 | 147 |
54 | Press n or j to go to the next uncovered block, b, p or k for the previous block. 55 |
56 || 1 60 | 2 61 | 3 62 | 4 63 | 5 64 | 6 65 | 7 66 | 8 67 | 9 68 | 10 69 | 11 70 | 12 71 | 13 72 | 14 73 | 15 74 | 16 75 | 17 76 | 18 77 | 19 78 | 20 79 | 21 80 | 22 81 | 23 82 | 24 83 | 25 84 | 26 85 | 27 86 | 28 87 | 29 88 | 30 89 | 31 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 1x 104 | 105 | 2x 106 | 107 | 18x 108 | 109 | 110 | 24x 111 | 112 | 7x 113 | 114 | 115 | 116 | 1x 117 | 118 | 119 | | //encontrar el indice de la primera aparicion de un string(needle)
120 | //dentro de otro(haystack)
121 | //no se puede utilizar indexOf()
122 |
123 | //ejemplo:
124 | //haystack = 'react-redux'
125 | //needle = 'redux'
126 | //output = 5
127 |
128 | //haystack = 'react-redux'
129 | //needle = 'hola'
130 | //output = -1
131 |
132 |
133 | module.exports = function findNeedle(haystack, needle) {
134 | // iteramos sobre el haystack
135 | for (let haystackIndex = 0; haystackIndex < haystack.length; haystackIndex += 1) {
136 | // comenzamos a iterar sobre el needle
137 | for (let needleIndex = 0; needleIndex < needle.length; needleIndex += 1 ) {
138 | // comparamos la letra del needle en la que estamos con la letra del haystack
139 | // cuando no hay match cortamos de comparar el needle
140 | if (haystack[haystackIndex + needleIndex] !== needle[needleIndex]) break;
141 | // si terminamos de recorrer la needle devolvemos el haystackIndex
142 | if (needleIndex + 1 === needle.length) return haystackIndex;
143 | }
144 | }
145 | // una vez que termina el loop devolvemos -1
146 | return -1;
147 | }
148 |
149 | |
54 | Press n or j to go to the next uncovered block, b, p or k for the previous block. 55 |
56 || 1 60 | 2 61 | 3 62 | 4 63 | 5 64 | 6 65 | 7 66 | 8 67 | 9 68 | 10 69 | 11 70 | 12 71 | 13 72 | 14 73 | 15 74 | 16 75 | 17 76 | 18 | 77 | 78 | 79 | 80 | 1x 81 | 2x 82 | 2x 83 | 8x 84 | 20x 85 | 86 | 20x 87 | 8x 88 | 89 | 90 | 91 | 92 | 2x 93 | | //Dado un arreglo de valores de acciones,
94 | //encontrar la mayor ganancia posible de comprar a un horario y vender después.
95 | //acciones: [4, 3, 2, 5, 11] mayor ganancia: 9;
96 |
97 | module.exports = function mayorGanancia(arrayAcciones) {
98 | let viejoMaximo = arrayAcciones[1] - arrayAcciones[0];
99 | for (let i = 0; i < arrayAcciones.length - 1; i += 1) {
100 | for (let j = i + 1; j < arrayAcciones.length; j += 1) {
101 | let gananciaPotencial = arrayAcciones[j] - arrayAcciones[i];
102 |
103 | if(viejoMaximo < gananciaPotencial){
104 | viejoMaximo = gananciaPotencial;
105 | }
106 | }
107 |
108 | }
109 | return viejoMaximo;
110 | } |
54 | Press n or j to go to the next uncovered block, b, p or k for the previous block. 55 |
56 || 1 60 | 2 61 | 3 62 | 4 63 | 5 64 | 6 65 | 7 66 | 8 67 | 9 68 | 10 69 | 11 70 | 12 71 | 13 72 | 14 73 | 15 74 | 16 75 | 17 76 | 18 77 | 19 78 | 20 79 | 21 80 | 22 81 | 23 82 | 24 83 | 25 84 | 26 85 | 27 86 | 28 87 | 29 88 | 30 89 | 31 90 | 32 91 | 33 92 | 34 93 | 35 94 | 36 95 | 37 96 | 38 97 | 39 98 | 40 99 | 41 100 | 42 101 | 43 102 | 44 103 | 45 104 | 46 105 | 47 106 | 48 107 | 49 108 | 50 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | | // Un stack o Pila es LIFO (last in first out),
158 | // osea el ultimo que entro es el primeor en salir.
159 | // Necesitas implementar un stack que tenga los siguientes métodos:
160 | // - push(value) // para añadir elementos
161 | // - pop() // para sacar un elemento
162 | // - min () // ver el elemento con el valor minimo Todas estas funciones tienen que correr en 0(1)
163 | // No se puede usar ningún array method
164 | // Idea: Tener una estructura separada para guardar el minimo
165 | // de cada nodo que se agrega,
166 | // y cuando sacamos el nodo removemos ese minimo.
167 |
168 | //dos clases, una con metodos pop,push,min
169 |
170 | class Node {
171 | constructor(value) {
172 | this.valor = value;
173 | this.next = null;
174 | }
175 | }
176 |
177 | class Stack {
178 | constructor(){
179 | this.primero = null;
180 | }
181 |
182 | push(elemento) {
183 | if(!this.primero){
184 | this.primero = new Node (elemento);
185 | }
186 |
187 | else {
188 | const nuevoNodo = new Node(elemento);
189 | nuevoNodo.next = this.primero;
190 | this.primero = nuevoNodo;
191 | }
192 | }
193 |
194 | pop() {
195 | const primeroSalir = this.primero;
196 | this.primero = primeroSalir && primeroSalir.next;
197 | return primeroSalir && primeroSalir.valor;
198 | }
199 |
200 | min(){
201 | return this.primero && this.primero.valor;
202 | }
203 | }
204 |
205 |
206 | |
54 | Press n or j to go to the next uncovered block, b, p or k for the previous block. 55 |
56 || 1 60 | 2 61 | 3 62 | 4 63 | 5 64 | 6 65 | 7 66 | 8 67 | 9 68 | 10 69 | 11 70 | 12 71 | 13 72 | 14 | 73 | 74 | 75 | 1x 76 | 10x 77 | 10x 78 | 25x 79 | 7x 80 | 81 | 18x 82 | 83 | 84 | 10x 85 | |
86 | //tu codigo aqui:
87 |
88 | module.exports = function mDSumArray(array) {
89 | var acc = 0;
90 | for (let i = 0; i < array.length; i++) {
91 | if (Array.isArray(array[i])) {
92 | acc = acc + mDSumArray(array[i])
93 | } else {
94 | acc = acc + array[i];
95 | }
96 | }
97 | return acc;
98 | } |
Encontrar el indice de la primera apariciónde un string (needle) dentro de otro(haystack)
7 |
37 | const findNeedle = (haystack, needle) => {
38 | // iteramos sobre el haystackfor
39 | (let haystackIndex = 0; haystackIndex < haystack.length; haystackIndex += 1) {
40 | // comenzamos a iterar sobre el needle
41 | for (let needleIndex = 0; needleIndex < needle.length; needleIndex += 1 ) {
42 | // comparamos la letra del needle en la que estamos con la letra del haystack
43 | // cuando no hay match cortamos de comparar el needle
44 | if (haystack[haystackIndex + needleIndex] !== needle[needleIndex]) break;
45 | // si terminamos de recorrer la needle devolvemos el haystackIndex
46 | if (needleIndex + 1 === needle.length) return haystackIndex;
47 | }
48 | }
49 | // una vez que termina el loop devolvemos -1
50 | return-1;
51 | }
52 | ???
58 |???
62 |
68 | const findNeedle = (haystack, needle) => {
69 | // iteramos sobre el haystack
70 | for (let haystackIndex = 0; haystackIndex < haystack.length; haystackIndex += 1) {
71 | // comenzamos a iterar sobre el needle
72 | for (let needleIndex = 0; needleIndex < needle.length; needleIndex += 1 ) {
73 | // comparamos la letra del needle en la que estamos con la letra del haystack
74 | // cuando no hay match cortamos de comparar el needle
75 | if (haystack[haystackIndex + needleIndex] !== needle[needleIndex]) break;
76 | // si terminamos de recorrer la needle devolvemos el haystackIndex
77 | if (needleIndex + 1 === needle.length) return haystackIndex;
78 | }
79 | }
80 | // una vez que termina el loop devolvemos -1
81 | return-1;
82 | }
83 | O(n*m)
89 |0(1)
93 |
100 | const findNeedle = (haystack, needle) => {
101 | // iteramos sobre el haystack
102 | for (let haystackIndex = 0; haystackIndex < haystack.length; haystackIndex += 1) {
103 | // comenzamos a iterar sobre el needle
104 | for (let needleIndex = 0; needleIndex < needle.length; needleIndex += 1 ) {
105 | // comparamos la letra del needle en la que estamos con la letra del haystack
106 | // cuando no hay match cortamos de comparar el needle
107 | if (haystack[haystackIndex + needleIndex] !== needle[needleIndex]) break;
108 | // si terminamos de recorrer la needle devolvemos el haystackIndex
109 | if (needleIndex + 1 === needle.length) return haystackIndex;
110 | }
111 | }
112 | // una vez que termina el loop devolvemos -1
113 | return-1;
114 | }
115 | O(n*m)
121 |0(1)
125 |
132 | function findNeedle2(haystack, needle){
133 | // iterar sobre el haystack
134 | for (let i = 0; i < haystack.length; i += 1) {
135 | // si la substring matchea el neddle podemos devoler el valor de i
136 | if (haystack.slice(i, i + needle.length) === needle) {
137 | return i;
138 | }
139 | }
140 | return-1;
141 | }
142 | ???
148 |???
152 |
159 | function findNeedle2(haystack, needle){
160 | // iterar sobre el haystack
161 | for (let i = 0; i < haystack.length; i += 1) {
162 | // si la substring matchea el neddle podemos devoler el valor de i
163 | if (haystack.slice(i, i + needle.length) === needle) {
164 | return i;
165 | }
166 | }
167 | return-1;
168 | }
169 | ???
175 |???
179 |Te preparamos para ingresar al mundo laboral brindándote las herramientas necesarias para conseguir un trabajo.
7 |Estos ejercicios te van a ayudar a prepararte para futuras entrevistas tecnicas , aprender o repasar conceptos y como encararlos. Son ejercicios de entrevistas reales.
8 |