En este capítulo se resuelven algunos problemas que involucran vectores. Para ese fin se emplean las estructuras for y for-of, así como los métodos iterativos disponibles para matrices estudiados en el capítulo anterior. En general, los problemas que involucran arreglos, se resuelven de forma más sencilla (aunque no necesariamente más eficiente) empleando los métodos disponibles.
Por ejemplo, para calcular el valor de la siguiente expresión:
| \[ \sum_{i=1}^{n}{v_i} \] |
Es decir, calcular la sumatoria de los elementos de un vector "v", como el siguiente:
La forma más simple consiste en llamar al método sum:
Igualmente (sobre todo si no se trabaja en la calculadora), se puede recurrir al método reduce:
El método reduce asigna, en la primera iteración, el valor del primer elemento (1) al primer parámetro de la función (al acumulador "s") y el valor del segundo elemento (2) al segundo parámetro ("e"). En la función se suma a "s" el valor de "e" (1+2 = 3). En la siguiente iteración, el resultado de la anterior iteración (3) es asignado al acumulador "s" y el valor del siguiente elemento (4) a "e", con lo que se calcula un nuevo resultado (3+4 = 7). El método prosigue de esa manera, asignando el resultado de la iteración anterior a "s" y el valor del nuevo elemento a "e", hasta que se llega al último elemento, añadiendo el mismo a "s". Ahora, como no existen más elementos, el resultado de la función (la sumatoria) es devuelto por el método.
Es posible, también, emplear el método forEach:
En este caso, debido a que la función que se manda a forEach sólo recibe, uno a uno, los elementos del vector (e), el acumulador "s" se inicializa en 0 fuera del método. En el método, en cada iteración, se suma a "s" el valor del elemento "e", con lo que, al terminar la última iteración, "s" tiene el valor de la sumatoria.
Se puede emplear también la estructura for-of, que es una variante de la estructura for y que tiene la siguiente sintaxis:
for (e of array) instrucciones;
Donde las instrucciones son ejecutadas para cada uno de los elementos e del array. El elemento e está disponible para que sea empleado en las instrucciones del ciclo.
Empleando esta estructura, la solución es similar a la del método forEach:
La única diferencia, con relación al método forEach es que, como la estructura for-of no recibe una función, sino que ejecuta instrucciones, en lugar de la función se escribe directamente la instrucción que suma a "s", uno a uno, los elementos "e" del vector. Es decir, en la primera iteración "e" vale 1 y se suma ese valor a "s", en la segunda "e" vale 2 y se suma ese valor a "s" y así sucesivamente.
Cuando no se dispone de un método adecuado para resolver el problema, se debe emplear la estructura for o la estructura for-of.
Como ya se vio previamente, una sumatoria (o productoria) con límites definidos, puede ser traducida directamente en un ciclo for, siendo los límites del ciclo los límites de la sumatoria (o productoria) y la variable de la sumatoria (o productoria) el contador del ciclo. El acumulador (la variable que almacena el resultado) debe iniciar en 0 si es una sumatoria y en 1 si es una productoria.
Así, para calcular la sumatoria, con la estructura for, se escribe:
Es importante recordar que, cuando se trabaja con vectores (y objetos en general), las variables son punteros, es decir variables que sólo guardan la dirección de memoria del lugar donde están almacenados los datos, pero no los datos en sí. Por esa razón, para efectivamente copiar un vector, se debe emplear el método slice (o el método copy).
En este ejemplo se programa un método para calcular el promedio de los valores almacenados en un vector "x", programando la expresión:
| \[ \bar{x} = \dfrac{\displaystyle\sum_{i=0}^{n-1}{x_i}}{n} \] |
Al ser un problema sencillo, puede ser codificado directamente (sin necesidad de elaborar un algoritmo): el contador del ciclo "i", debe comenzar en 0 e ir hasta "n-1", incrementando en 1 en cada repetición del ciclo. El acumulador que se emplee, por ejemplo "s", debe comenzar en cero y en cada repetición del ciclo se le debe añadir el valor de x[i].
Sólo para que la lógica resulte aún más clara, se elabora el diagrama de flujo respectivo:
Observe que la condición del ciclo es "i<n", que es equivalente a la condición "i<=n-1", sólo que es más corta y más eficiente: se compara sólo si es menor, no si es menor o igual, además no es necesario restar 1 al número. Igualmente, dado que los índice (en este caso) son números enteros, la condición del ciclo podría ser "i!=n", porque el ciclo se debe repetir mientras el contador sea diferente al número de elementos del array. Cuando es igual el índice está apuntando a un elemento inexistente, debido a que (como se recordará) el primer índice de un array es 0 y el último n-1.
El código respectivo, es:
Llamando a la función con algunos valores de prueba, se obtiene:
Como se puede ver en estos ejemplos, antes de generar los vectores con números aleatorios, se ha iniciado la semilla (randseed) en 1, con lo que se genera la misma secuencia de números pseudoaleatorios (se recuerda que, para volver a generar números realmente aleatorios, se debe asignar el valor null a la variable randseed ).
El problema resuelto con la estructura for-of, es:
En este caso, la estructura for-of, extrae uno a uno los elementos "e" del vector, los cuales se añaden al acumulador "s".
El problema resuelto con el método forEach, es:
En cada iteración, el método forEach manda a la función (en este ejemplo una función flecha) el valor del elemento actual, ese valor es recibido (en este ejemplo) en la variable "e". Dentro de la función, ese valor es añadido a la variable "s" ("s+=e"), por lo tanto, en cada iteración, se añade a "s", el valor de un nuevo elemento, con lo que, al final del proceso "s" tiene el valor de la suma de todos los elementos del array. Como se vio en el capítulo anterior, además del valor del elemento ("e"), forEach manda también el índice (la posición) del elemento actual, así como el array en sí, sin embargo, en este ejemplo, no se reciben esos valores, porque no son utilizados dentro de la función.
El problema resuelto con el método reduce, es:
Como se explicó previamente, reduce devuelve el valor de la sumatoria, el cual es dividido entre el número de elementos, con lo que se obtiene el promedio.
Como sucede con casi todos los métodos iterativos para arrays, reduce manda, además, el índice actual y el array en sí, pero, al igual que con forEach estos valores no son recibidos, porque no se emplean dentro de la función.
Si en reduce se emplea un valor inicial (el parámetro opcional), ese valor es asignado al acumulador en la primera iteración (en lugar del primer elemento del array). Así, la solución del ejemplo, pero empleando un valor inicial, es:
En este caso, como se manda un valor inicial (0), reduce asigna ese valor al primer parámetro de la función (al acumulador) y asigna al segundo parámetro el valor del primer elemento. El resultado es el mismo porque, al ser el valor inicial 0, no afecta al resultado (pues es una sumatoria). La única diferencia es que ahora reduce hace una iteración más. En otros casos, sin embargo, el proporcionar (o no) un valor inicial, puede dar lugar a resultados completamente diferentes.
El problema resuelto con el método sum, es:
Igualmente, el problema puede ser resuelto con el método map:
El método map opera de forma similar a forEach, excepto que (como ya se vio en el anterior capítulo) genera un nuevo array (de igual dimensión que el array original), donde cada elemento es el resultado devuelto por la función en cada iteración. En este ejemplo, ese array es simplemente ignorado, por lo que, para este problema en particular, el método map no es muy eficiente.
También se puede emplear el método every:
Donde, para que el método itere para todos los elementos del array, la función devuelve true. Obviamente, debido a este paso adicional, no es un método adecuado para resolver este problema, sin embargo, es posible su uso, porque, a pesar de que su propósito es el verificar si todos los elementos de un array cumplen (o no) una determinada condición (el método termina y devuelve false, si la condición es falsa para cualquiera de los elementos), en cada iteración la función recibe el valor del elemento, el cual puede ser empleado igual que forEach, recordando que el valor devuelto por la función debe ser true (o un valor equivalente a true, como el número 1 por ejemplo).
Observe que en este caso la función tiene dos instrucciones "s+=e" y "true", por eso ha sido encerrada entre paréntesis y las instrucciones separadas con una coma (no con un punto y coma). Cuando el cuerpo de una función se encierra entre paréntesis, es tratada como una expresión, las instrucciones (separadas con comas) son evaluadas de forma secuencial y el valor de la última expresión (en este caso true) es el valor devuelto por la función. Se emplean paréntesis, simplemente porque la función resultante es más compacta, sin embargo, la función puede ser programada también de la forma tradicional, es decir con llaves y el comando return, como se muestra a continuación:
Igualmente, se puede emplear el método some (que es el complemento de every):
Al igual que con every, se fuerza a que some itere para todos los elementos del array, haciendo que la función devuelva false (porque some termina y devuelve true cuando la función es verdadera para cualquiera de los elementos del array).
De forma similar se pueden emplear los métodos find, findIndex, findLast, findLastIndex y filter. Sin embargo, se recalca que ninguno de estos métodos es adecuado para resolver este tipo de problemas, sólo son empleados en la asignatura (en este tipo de problemas) a manera de ejercicio, pero no deben ser empleados, en aplicaciones reales para resolver problemas similares al presente.
En este ejemplo se elabora un método que genera un vector con "n" números aleatorios comprendidos entre 1 y 1000.
El problema puede ser resuelto fácilmente con el método rand: simplemente se generan "n" números aleatorios comprendidos entre 1 y 1000 y se redondea el vector resultante, tal como se muestra en la siguiente función:
Llamando a la función con algunos valores de prueba, se obtiene:
Si no se tiene acceso al método rand, porque no se está trabajando en la calculadora o no se ha importado la librería array.js, el problema puede ser resuelto empleando la estructura for y la función estándar random.
Para transformar el número aleatorio comprendido entre 0 y 1, que es el resultado devuelto por random, en un número comprendido entre "li" y "ls", se aplica la siguiente expresión:
| \[ \begin{aligned} \text{Nú}&\text{mero aleatorio comprendido entre li y ls}=\\ &(\text{Número aleatorio comprendido entre 0 y 1})\times (\text{ls}-\text{li})+\text{li} \end{aligned} \] |
Entonces, en cada repetición del ciclo for, que va desde 0 hasta "n-1", se genera y guarda un número aleatorio, como se muestra en el siguiente diagrama de flujo:
Siendo el código respectivo:
La solución, implementada empleando el método push (en lugar de una asignación directa), es:
El problema puede ser resuelto, también, empleando la estructura for-of:
Como el método for-of itera para cada uno de los elementos de un array, pero en este caso no existe ese array, primero se crea uno, con Array.from({length:n}) (un array con "n" elementos "undefined"), entonces for-of itera para cada uno de los elementos de ese array. No obstante, como esos elementos no son empleados en el ciclo, se denota ese hecho recibiéndolos en el parámetro "_". En cada repetición del ciclo for-of, se genera y añade al vector "v", un número aleatorio.
Dado que en este tipo de solución, no se emplean los elementos del array, sólo interesa el número de elementos, los "n" elementos pueden ser generados con cualquiera de los métodos conocidos: const, range y zeros, etc.
Por ejemplo, con el método forEach y range (para generar el array), la solución es:
Donde, con range, se crea un vector con "n" elementos (de 1 al n) y se llama al método desde ese vector. Al igual que el caso anterior, como no se emplean los elementos del array, la función no recibe ningún elemento.
El problema resuelto con el método reduce y zeros (para generar el array), es:
En este ejemplo, al igual que en los anteriores, no se emplean los elementos del array, por lo que la función solo recibe el primer parámetro (el acumulador) "v". Se manda como valor inicial un vector vacío ([]), el cual es asignado en la primera iteración a "v", luego, en cada iteración, se genera un número aleatorio que se añade (con push) a "v" y se devuelve el vector con el nuevo valor añadido (, v). Por lo tanto, a partir de la segunda iteración, reduce asigna el vector con el nuevo elemento al acumulador "v", de manera que "v" siempre tiene el vector con el último elemento añadido. Finalmente en la última iteración reduce devuelve el valor de "v" (el vector con todos los números aleatorios añadidos).
El problema puede ser resuelto, también, con el método some, aunque, como se explicó previamente, no es la opción correcta para este tipo de problemas:
Igual que en los casos anteriores, no se emplean los elementos del array, razón por la cual la función no recibe ningún valor y, para que el método itere con todos los elementos del array, la función devuelve false.
De la misma forma, se puede emplear el método every:
Que esencialmente es igual a la solución anterior, solo que en este caso el array se genera con el método range y la función devuelve true para que el método itere con todos los elementos del array.
El problema puede ser resuelto, igualmente, con el método map.
Al igual que en los casos anteriores, como no se emplean los elementos del array, la función no recibe ningún valor, pero como el método map devuelve un nuevo array con valores iguales a los resultados de la función y la función devuelve (en cada iteración) un número aleatorio, el array resultante es directamente el array de números aleatorios devuelto por map.
De forma similar y al igual que en el ejemplo anterior, el problema puede ser resuelto, también, con find, findIndex, findLast, findLastIndex y filter, sin embargo, se reitera que estos métodos no son la opción correcta para resolver este tipo de problemas. Se emplean en este capítulo solamente para adquirir práctica en su uso, pero no deben ser empleados, en estos casos, en la solución de problemas reales.