Iteración 1

Las estructuras iterativas, conocidas también como estructuras repetitivas, bucles o ciclos, son aquellas que repiten la ejecución de una o más instrucciones, una o más veces.

La estructura "while" (mientras)

La estructura while, es la estructura iterativa por excelencia. Esta estructura repite la ejecución de una o más intrucciones mientras la condición del ciclo es verdadera.

El algoritmo de esta estructura, es:

gojsGraph({divi, modelo: {"class":"go.GraphLinksModel","linkFromPortIdProperty":"fromPort","linkToPortIdProperty":"toPort","nodeDataArray":[{"category":"Conditional","text":"condición","key":-5,"loc":"-46.00000000000003 -297.00000000000006"},{"category":"Process","text":"instrucciones","key":-2,"loc":"-46.000000000000085 -216.79999995231634"},{"category":"Connector","text":"...","key":-8,"loc":"-46 -358"},{"category":"Connector","text":"...","key":-4,"loc":"-46.409035948064144 -148.63614379225646"}],"linkDataArray":[{"from":-5,"to":-2,"fromPort":"B","toPort":"T","visible":true,"points":[-46.00000000000003,-276.96664276123056,-46.00000000000003,-266.96664276123056,-46.00000000000003,-255.51666066646584,-46.000000000000085,-255.51666066646584,-46.000000000000085,-244.06667857170112,-46.000000000000085,-234.06667857170112],"text":"Si"},{"from":-8,"to":-5,"fromPort":"B","toPort":"T","points":[-46,-343.3042461927547,-46,-333.3042461927547,-46,-330.16880171576213,-46.00000000000003,-330.16880171576213,-46.00000000000003,-327.0333572387696,-46.00000000000003,-317.0333572387696]},{"from":-2,"to":-5,"fromPort":"L","toPort":"L","points":[-97.29248046875009,-216.79999995231634,-107.29248046875009,-216.79999995231634,-144,-216.79999995231634,-144,-297.00000000000006,-120.49705505371097,-297.00000000000006,-110.49705505371097,-297.00000000000006]},{"from":-5,"to":-4,"fromPort":"R","toPort":"T","visible":true,"points":[18.49705505371091,-297.00000000000006,28.49705505371091,-297.00000000000006,59,-297.00000000000006,59,-189,-46.409035948064144,-189,-46.409035948064144,-173.33189759950176,-46.409035948064144,-163.33189759950176],"text":"No"}]} })

Es decir que si la condición es verdadera (Si) se ejecutan las instrucciones del ciclo, luego se vuelve a preguntar si la condición es verdadera y de ser así, se vuelven a ejecutar las instrucciones del ciclo, continuando así mientras la condición es verdadera (Si). Cuando la condición es falsa (No), el programa sale del ciclo y continúa con el resto de las instrucciones existentes.

La sintaxis de esta estructura, en Javascript, es:

while (condición) { instrucciones del ciclo; }

Por ejemplo, el siguiente algoritmo, muestra los números comprendidos entre 3 y 9: la variable "i" (el contador) inicia en 3 y mientras la condición del ciclo es verdadera, es decir, mientras "i" es menor o igual a 9, se muestra el valor de la variable y se incrementa su valor en uno (antes de repetir el ciclo):

El código respectivo (escrito y ejecutado en la calculadora) es:

var i = 3;
while (i<=9) {
print("i = "+i);
i++;
};

En este ejemplo, el valor de la variable "i", se incrementa empleando el operador compuesto ++: la instrucción i++, es equivale a i = i+1).

Es importante notar que, si el valor de la variable no se incrementa antes de repetir el ciclo, el ciclo se repetiría por siempre, porque el valor de "i" (al no incrementar) siempre sería igual a 3, por lo tanto siempre sería menor a 9, dando lugar a lo que se conoce como un ciclo infinito.

Los ciclos infinitos constituyen un error común cuando se trabaja con ciclos repetitivos y provocan el bloqueo de la página (la página se cuelga), esto ocurre porque, la ejecución continua del ciclo impide que la página haga otra cosa.

Cuando el programa ingresa a un ciclo infinito, no queda otra alternativa que cerrar la pagina, con lo que se pierde el trabajo realizado. Por esa razón, cuando se trabaja con ciclos repetitivos, se debe revisar cuidadosamente la lógica, verificando que el ciclo concluya (que la condición sea falsa) en algún momento durante la ejecución del ciclo.

En programación, siempre existe más de una forma de resolver un mismo problema, así, en este caso, en lugar de preguntar si el número es menor o igual a 9, se puede preguntar si es menor a 10:

Siendo el código respectivo:

var i = 3;
while (i<10) {
print("i = "+i);
i++;
};

Igualmente, la variable "i" (el contador) puede ser iniciada en 2 y en el ciclo, que ahora se repite mientras la variable "i" es menor a 9 (o menor o igual a 8), se debe incrementar primero el valor del contador y luego recién mostrar su valor, porque de lo contrario, la serie resultante sería: 2, 3, 4, 5, 6, 7, 8 (haga la prueba):

Siendo el código respectivo:

var i = 2;
while (i<9) {
i++;
print("i = "+i);
};

Y se puede pensar en otras formas más de resolver este problema.

Además del operador compuesto ++, en Javascript se pueden emplear los siguientes operadores compuestos:

Operadores Compuestos
Operador	Definición
++	Incremento \((x\text{+}\text{+} \iff x=x+1)\)
−−	Decremento \((x-- \iff x=x-1)\)
+=	Suma compuesta \((x\text{+=}5 \iff x=x+5\))
−=	Resta compuesta \((x-=5 \iff x=x-5)\)
*=	Multiplicación compuesta \((x\text{=}5 \iff x=x5)\)
/=	División compuesta \((x\text{/=}5 \iff x=x/5)\)
%=	Residuo compuesto \((x\%= 5 \iff x=x\%5)\)
**=	Potencia compuesta \((x= 5 \iff x=x5)\)

Así, para codificar el siguiente algoritmo, donde se muestran los número impares comprendidos entre 5 y 17:

Se emplea el operador compuesto +=:

var i = 5;
while (i<=17) {
print("i = "+i);
i += 2;
};

A partir de este capítulo, se deben emplear operadores compuestos en todos los casos en los que sea posible.

La estructura do-while (hacer-mientras)

La estructura do-while, es similar a la estructura while, sólo que la condición se encuentra al final del ciclo, por lo que, en esta estructura, las instrucciones del ciclo se ejecutan por lo menos una vez.

El algoritmo de esta estructura, es:

gojsGraph({divi, modelo: {"class":"go.GraphLinksModel","linkFromPortIdProperty":"fromPort","linkToPortIdProperty":"toPort","nodeDataArray":[{"category":"Conditional","text":"condición","key":-5,"loc":"-46.00000000000003 -233.00000000000006"},{"category":"Process","text":"instrucciones","key":-2,"loc":"-46.000000000000085 -298.79999995231634"},{"category":"Connector","text":"...","key":-8,"loc":"-46 -358"},{"category":"Connector","text":"...","key":-4,"loc":"-46.409035948064144 -157.63614379225646"}],"linkDataArray":[{"from":-8,"to":-2,"fromPort":"B","toPort":"T","points":[-46,-343.3042461927547,-46,-333.3042461927547,-46,-329.6854623822279,-46.000000000000085,-329.6854623822279,-46.000000000000085,-326.0666785717011,-46.000000000000085,-316.0666785717011]},{"from":-2,"to":-5,"fromPort":"B","toPort":"T","points":[-46.000000000000085,-281.53332133293156,-46.000000000000085,-271.53332133293156,-46.000000000000085,-267.2833392858506,-46.00000000000003,-267.2833392858506,-46.00000000000003,-263.0333572387696,-46.00000000000003,-253.0333572387696]},{"from":-5,"to":-2,"fromPort":"L","toPort":"L","visible":true,"points":[-110.49705505371097,-233.00000000000009,-120.49705505371097,-233.00000000000009,-144,-233.00000000000009,-144,-298.79999995231634,-107.29248046875009,-298.79999995231634,-97.29248046875009,-298.79999995231634],"text":"Si"},{"from":-5,"to":-4,"fromPort":"B","toPort":"T","visible":true,"points":[-46.00000000000003,-212.96664276123056,-46.00000000000003,-202.96664276123056,-46.00000000000003,-192.64927018036616,-46.409035948064144,-192.64927018036616,-46.409035948064144,-182.33189759950176,-46.409035948064144,-172.33189759950176],"text":"No"}]} })

Es decir que primero se ejecutan las instrucciones del ciclo, luego, si la condición es verdadera (Si), se vuelven a ejecutar las instrucciones del ciclo, continuando de esta manera hasta que la condición es falsa (No), momento en el cual, el ciclo concluye y el programa continua con la ejecución del resto de las instrucciones.

La sintaxis de esta estructura, en Javascript, es:

do { instrucciones del ciclo; } while (condición);

Con frecuencia se pueden emplear las estructuras while y do-while indistintamente. Por ejemplo, los números impares del 5 al 17, pueden ser generados y mostrados, igualmente, con la estructura do-while:

Siendo el código respectivo:

var i = 5;
do {
print("i = "+i);
i += 2;
} while (i<=17);

A continuación se resuelve algunos ejemplos empleando estas estructuras.

Ejemplos

Sumatoria de los primeros "n" números pares

El propósito de este ejemplo es el programar un método que devuelva la sumatoria de los primeros "n" números pares, así, si el número es 5, el método debe devolver la sumatoria de los primeros 5 números pares, es decir, la sumatoria de: 2, 4, 6, 8 y 10.

Para resolver el problema se inicializa la variable que guarda el resultado, denominada acumulador (en este ejemplo "s") en cero. Su valor inicial es cero, porque el cero es el valor neutro de la suma: si se suma cero a cualquier número el resultado es el mismo número (en el caso de la multiplicación el valor neutro es el 1).

Para sumar los números pares se tienen al menos dos opciones. En la primera, comenzando con el primer número par (el número 2), se genera en el ciclo un nuevo número par (añadiendo 2 al valor anterior). En esta opción el ciclo se repite mientras el contador ("i") es menor o igual al último número par que se debe generar: 2*n:

gojsGraph({divi, modelo: {"class":"go.GraphLinksModel","linkFromPortIdProperty":"fromPort","linkToPortIdProperty":"toPort","nodeDataArray":[{"category":"Start","text":"sumPares","key":-1,"loc":"-60.00000000000007 -505.9999999999998"},{"category":"Conditional","text":"i<=2*n","key":-5,"loc":"-60.000000000000114 -278.9999999999997"},{"category":"Output","text":"s","key":-4,"loc":"-59.8384638924495 -84.97896365880774"},{"category":"Process","text":"i = 2","key":-2,"loc":"-60.00000000000003 -338.7999999523163"},{"category":"Start","text":"fin","key":-9,"loc":"-59.584679289086324 -32.34386302527511"},{"category":"Process","text":"s = s+i","key":-6,"loc":"-59.53032135064534 -208.4477711377669"},{"category":"Input","text":"número entero positivo: n","key":-3,"loc":"-60 -450.2000002861023"},{"category":"Process","text":"s = 0","key":-8,"loc":"-60.00000000000003 -394.7999999523163"},{"category":"Process","text":"i = i+2","key":-10,"loc":"-59.41532071091359 -150.79999995231628"}],"linkDataArray":[{"from":-1,"to":-3,"fromPort":"B","toPort":"T","points":[-60.000000000000064,-490.73332138061494,-60.000000000000064,-480.73332138061494,-60.000000000000064,-477.60000014305103,-60,-477.60000014305103,-60,-474.4666789054871,-60,-464.4666789054871]},{"from":-3,"to":-8,"fromPort":"B","toPort":"T","points":[-60,-435.9333216667175,-60,-425.9333216667175,-60,-424.0000001192093,-60.00000000000003,-424.0000001192093,-60.00000000000003,-422.06667857170106,-60.00000000000003,-412.06667857170106]},{"from":-8,"to":-2,"fromPort":"B","toPort":"T","points":[-60.00000000000003,-377.5333213329315,-60.00000000000003,-367.5333213329315,-60.00000000000003,-366.7999999523163,-60.00000000000003,-366.7999999523163,-60.00000000000003,-366.06667857170106,-60.00000000000003,-356.06667857170106]},{"from":-2,"to":-5,"fromPort":"B","toPort":"T","points":[-60.00000000000003,-321.5333213329315,-60.00000000000003,-311.5333213329315,-60.00000000000003,-310.2833392858504,-60.000000000000114,-310.2833392858504,-60.000000000000114,-309.03335723876927,-60.000000000000114,-299.03335723876927]},{"from":-5,"to":-6,"fromPort":"B","toPort":"T","visible":true,"points":[-60.000000000000114,-258.9666427612302,-60.000000000000114,-248.96664276123022,-60.000000000000114,-242.34054625919094,-59.53032135064534,-242.34054625919094,-59.53032135064534,-235.71444975715167,-59.53032135064534,-225.71444975715167],"text":"Si"},{"from":-6,"to":-10,"fromPort":"B","toPort":"T","points":[-59.53032135064534,-191.18109251838214,-59.53032135064534,-181.18109251838214,-59.53032135064534,-179.62388554504162,-59.41532071091359,-179.62388554504162,-59.41532071091359,-178.06667857170106,-59.41532071091359,-168.06667857170106]},{"from":-10,"to":-5,"fromPort":"L","toPort":"L","points":[-87.25183041550343,-150.79999995231628,-97.25183041550343,-150.79999995231628,-142.07706724800428,-150.79999995231628,-142.07706724800428,-278.9999999999997,-115.77627563476574,-278.9999999999997,-105.77627563476574,-278.9999999999997]},{"from":-5,"to":-4,"fromPort":"R","toPort":"T","visible":true,"points":[-14.223724365234489,-278.9999999999997,-4.223724365234489,-278.9999999999997,26.895247297976084,-278.9999999999997,26.895247297976084,-122.89958673324719,-59.8384638924495,-122.89958673324719,-59.8384638924495,-112.5900946911157,-59.8384638924495,-102.5900946911157],"text":"No"},{"from":-4,"to":-9,"fromPort":"B","toPort":"T","points":[-59.8384638924495,-72.29894931554603,-59.8384638924495,-62.298949315546025,-59.8384638924495,-59.95474548010297,-59.584679289086324,-59.95474548010297,-59.584679289086324,-57.61054164465992,-59.584679289086324,-47.61054164465992]}]} })

En la segunda alternativa el ciclo se repite "n" veces, el contador "i" inicia en 1, se incrementa en 1 en el ciclo y Los números pares se calculan (y añaden al acumulador) multiplicando el contador por 2:

gojsGraph({divi, modelo: {"class":"go.GraphLinksModel","linkFromPortIdProperty":"fromPort","linkToPortIdProperty":"toPort","nodeDataArray":[{"category":"Start","text":"sumPares2","key":-1,"loc":"-60.00000000000007 -505.9999999999998"},{"category":"Conditional","text":"i<=n","key":-5,"loc":"-60.000000000000114 -278.9999999999997"},{"category":"Output","text":"s","key":-4,"loc":"-59.8384638924495 -84.97896365880774"},{"category":"Process","text":"i = 1","key":-2,"loc":"-60.00000000000003 -338.7999999523163"},{"category":"Start","text":"fin","key":-9,"loc":"-59.584679289086324 -32.34386302527511"},{"category":"Process","text":"s = s+2*i","key":-6,"loc":"-59.53032135064534 -208.4477711377669"},{"category":"Input","text":"número entero positivo: n","key":-3,"loc":"-60 -450.2000002861023"},{"category":"Process","text":"s = 0","key":-8,"loc":"-60.00000000000003 -394.7999999523163"},{"category":"Process","text":"i = i+1","key":-10,"loc":"-59.41532071091359 -150.79999995231628"}],"linkDataArray":[{"from":-1,"to":-3,"fromPort":"B","toPort":"T","points":[-60.00000000000006,-490.7333213806148,-60.00000000000006,-480.7333213806148,-60.00000000000006,-477.60000014305103,-60,-477.60000014305103,-60,-474.4666789054871,-60,-464.4666789054871]},{"from":-3,"to":-8,"fromPort":"B","toPort":"T","points":[-60,-435.9333216667175,-60,-425.9333216667175,-60,-424.0000001192093,-60.00000000000003,-424.0000001192093,-60.00000000000003,-422.06667857170106,-60.00000000000003,-412.06667857170106]},{"from":-8,"to":-2,"fromPort":"B","toPort":"T","points":[-60.00000000000003,-377.5333213329315,-60.00000000000003,-367.5333213329315,-60.00000000000003,-366.7999999523163,-60.00000000000003,-366.7999999523163,-60.00000000000003,-366.06667857170106,-60.00000000000003,-356.06667857170106]},{"from":-2,"to":-5,"fromPort":"B","toPort":"T","points":[-60,-321.5333213329315,-60,-311.5333213329315,-60,-310.2833392858504,-60.00000000000014,-310.2833392858504,-60.00000000000014,-309.03335723876944,-60.00000000000014,-299.03335723876944]},{"from":-5,"to":-6,"fromPort":"B","toPort":"T","visible":true,"points":[-60.00000000000014,-258.9666427612304,-60.00000000000014,-248.9666427612304,-60.00000000000014,-242.34054625919094,-59.53032135064532,-242.34054625919094,-59.53032135064532,-235.7144497571517,-59.53032135064532,-225.7144497571517],"text":"Si"},{"from":-6,"to":-10,"fromPort":"B","toPort":"T","points":[-59.53032135064532,-191.18109251838217,-59.53032135064532,-181.18109251838217,-59.53032135064532,-179.62388554504162,-59.41532071091359,-179.62388554504162,-59.41532071091359,-178.06667857170106,-59.41532071091359,-168.06667857170106]},{"from":-10,"to":-5,"fromPort":"L","toPort":"L","points":[-87.25183041550343,-150.79999995231628,-97.25183041550343,-150.79999995231628,-142.07706724800428,-150.79999995231628,-142.07706724800428,-278.9999999999999,-101.40948486328139,-278.9999999999999,-91.40948486328139,-278.9999999999999]},{"from":-5,"to":-4,"fromPort":"R","toPort":"T","visible":true,"points":[-28.590515136718892,-278.9999999999999,-18.590515136718892,-278.9999999999999,26.895247297976084,-278.9999999999999,26.895247297976084,-122.89958673324719,-59.8384638924495,-122.89958673324719,-59.8384638924495,-112.5900946911157,-59.8384638924495,-102.5900946911157],"text":"No"},{"from":-4,"to":-9,"fromPort":"B","toPort":"T","points":[-59.8384638924495,-72.29894931554603,-59.8384638924495,-62.298949315546025,-59.8384638924495,-59.95474548010297,-59.584679289086324,-59.95474548010297,-59.584679289086324,-57.61054164465992,-59.584679289086324,-47.61054164465992]}]} })

De estas dos opciones la primera es un tanto más eficiente, porque, en cada iteración, solo se suma 2 al contador, mientras que en la segunda se multiplica el contador por 2, lo que requiere más tiempo y memoria.

El código respectivo, implementado como una función expresión (función anónima), es:

var sumPares = function(n) {
if (!Number.isInteger(n)) throw "El número debe ser entero";
if (n<0) throw "El número debe ser positivo";
let s = 0;
let i = 2;
while (i <= 2*n) {
s += i;
i += 2;
}
return s;
};

Donde, por un lado se valida que el número sea entero y por otro que sea positivo. Llamando al método con algunos valores de prueba, se obtiene:

sumPares(0)

sumPares(5)

sumPares(12)

sumPares(7.3)

sumPares(-10)

En este problema no es conveniente emplear la estructura do-while, porque, cuando el número es cero o negativo se obtendría 2 en lugar de cero, esto debido a que las instrucciones, en este tipo de ciclo, se ejecutan siempre por lo menos una vez, por lo tanto se sumaría 2 al acumulador (s+2 = 0+2 == 2). Para corregir este error sería necesario añadir una condición if antes del ciclo (if (n===0) return 0;), con lo que la solución resultaría más larga.

Invertir los dígitos de un número

En este ejemplo se programa un método que devuelve el número entero (positivo o negativo) desde el cual es llamado, con sus dígitos invertidos. Así, si el método es llamado desde el número 12345, devuelve 54321.

El problema se resuelve comprendiendo que el residuo de dividir el número entero entre 10 es su último dígito y que el cociente es el número sin su último dígito. Así si el número a invertir "n", es 12345, el cociente y el residuo de su división entre 10, es:

\[ \begin{array}{c} 12345\\ (5) \end{array} \begin{array}{|c} \phantom{12}10\phantom{12} \\ \hline 1234 \end{array} \]

Ahora bien, el residuo (el número 5) debe ser el primer dígito del número invertido. Si se denomina "ni" al número invertido y se le asigna un valor inicial igual a 0, el residuo (el número 5) se asigna a "ni", con la siguiente operación:

\[ ni = ni*10+5 = 0*10+5 = 0+5 = 5 \]

Donde, el número invertido ("ni") se multiplica por 10 para que su último dígito sea 0 (por ejemplo, 579*10, devuelve 5790, donde el último dígito es 0). En esta iteración (la primera) no se requiere esa multiplicación, porque el número es 0, por lo tanto ya tiene un 0 como último dígito, sin embargo, como en el resto de las iteraciones se debe repetir el mismo procedimiento, se mantiene la multiplicación inclusive para la primera iteración.

Para la segunda iteración se emplea el cociente, por lo tanto ahora, el número "n" es 1234:

\[ \begin{array}{c} 1234\\ (4) \end{array} \begin{array}{|c} \phantom{12}10\phantom{12} \\ \hline 123 \end{array} \]

Y se añade el nuevo residuo al número invertido "ni"::

\[ ni = ni*10+4 = 5*10+4 = 50+4 = 54 \]

Ahora, como se puede ver, la multiplicación es necesaria para que el último dígito sea 0 y que al sumarle el residuo, el residuo quede en la última posición (sin la multiplicación, el residuo, se sumaría al número existente: 5+4=9, con lo que no se obtendría el resultado buscado).

Repitiendo el procedimiento, siendo ahora el número "n" el nuevo cociente: 123, se obtiene:

\[ \begin{array}{c} 123\\ (3) \end{array} \begin{array}{|c} \phantom{12}10\phantom{12} \\ \hline 12 \end{array} \]

\[ ni = ni*10+3 = 54*10+3 = 540+3 = 543 \]

Repitiendo una vez más el procedimiento, siendo ahora el número "n" 12, se obtiene:

\[ \begin{array}{c} 12\\ (2) \end{array} \begin{array}{|c} \phantom{12}10\phantom{12} \\ \hline 1 \end{array} \]

\[ ni = ni*10+2 = 543*10+2 = 5430+2 = 5432 \]

Finalmente, repitiendo el procedimiento con el cociente restante 1 (n=1), se obtiene:

\[ \begin{array}{c} 1\\ (1) \end{array} \begin{array}{|c} \phantom{12}10\phantom{12} \\ \hline 0 \end{array} \]

\[ ni = ni*10+1 = 5432*10+1 = 54320+1 = 54321 \]

Como ahora el cociente es 0 (el número no tiene más dígitos), el proceso concluye, siendo el número invertido "ni": 54321.

El algoritmo, en forma de un diagrama de flujo, es:

gojsGraph({divi, modelo: {"class":"go.GraphLinksModel","linkFromPortIdProperty":"fromPort","linkToPortIdProperty":"toPort","nodeDataArray":[{"category":"Start","text":"invertirDigitos","key":-1,"loc":"-60.00000000000007 -505.9999999999998"},{"category":"Conditional","text":"n!=0","key":-5,"loc":"-60.00000000000014 -330.99999999999966"},{"category":"Output","text":"ni","key":-4,"loc":"-59.83846389244948 -136.97896365880774"},{"category":"Start","text":"fin","key":-9,"loc":"-59.584679289086324 -84.34386302527514"},{"category":"Process","text":"ni = ni*10+n%10","key":-6,"loc":"-59.53032135064538 -260.44777113776695"},{"category":"Input","text":"número entero: n","key":-3,"loc":"-60 -450.2000002861023"},{"category":"Process","text":"ni = 0","key":-8,"loc":"-60.00000000000003 -394.7999999523163"},{"category":"Process","text":"n = quot(n,10)","key":-10,"loc":"-59.41532071091355 -202.7999999523163"}],"linkDataArray":[{"from":-1,"to":-3,"fromPort":"B","toPort":"T","points":[-60.0000000000001,-490.73332138061494,-60.0000000000001,-480.73332138061494,-60.0000000000001,-477.60000014305103,-60.00000000000003,-477.60000014305103,-60.00000000000003,-474.4666789054871,-60.00000000000003,-464.4666789054871]},{"from":-3,"to":-8,"fromPort":"B","toPort":"T","points":[-60.00000000000003,-435.9333216667175,-60.00000000000003,-425.9333216667175,-60.00000000000003,-424.0000001192093,-60,-424.0000001192093,-60,-422.066678571701,-60,-412.066678571701]},{"from":-5,"to":-6,"fromPort":"B","toPort":"T","visible":true,"points":[-60.00000000000014,-310.96664276123016,-60.00000000000014,-300.96664276123016,-60.00000000000014,-294.34054625919094,-59.53032135064538,-294.34054625919094,-59.53032135064538,-287.7144497571517,-59.53032135064538,-277.7144497571517],"text":"Si"},{"from":-6,"to":-10,"fromPort":"B","toPort":"T","points":[-59.53032135064538,-243.1810925183822,-59.53032135064538,-233.1810925183822,-59.53032135064538,-231.62388554504165,-59.41532071091355,-231.62388554504165,-59.41532071091355,-230.0666785717011,-59.41532071091355,-220.0666785717011]},{"from":-4,"to":-9,"fromPort":"B","toPort":"T","points":[-59.83846389244948,-124.29894931554603,-59.83846389244948,-114.29894931554603,-59.83846389244948,-111.95474548010296,-59.584679289086324,-111.95474548010296,-59.584679289086324,-109.61054164465989,-59.584679289086324,-99.61054164465989]},{"from":-8,"to":-5,"fromPort":"B","toPort":"T","points":[-60,-377.53332133293145,-60,-367.53332133293145,-60,-364.28333928585033,-60.00000000000014,-364.28333928585033,-60.00000000000014,-361.0333572387692,-60.00000000000014,-351.0333572387692]},{"from":-5,"to":-4,"fromPort":"R","toPort":"T","visible":true,"points":[-27.315093994140767,-330.99999999999966,-17.315093994140767,-331.100000143051,41,-331.100000143051,41,-172,-59.83846389244948,-172,-59.83846389244948,-164.5900946911157,-59.83846389244948,-154.5900946911157],"text":"No"},{"from":-10,"to":-5,"fromPort":"L","toPort":"L","points":[-112.58429654099167,-202.7999999523163,-122.58429654099167,-202.4910477209785,-159,-202.4910477209785,-159,-330.99999999999966,-102.68490600585952,-330.99999999999966,-92.68490600585952,-330.99999999999966]}]} })

Siendo el código respectivo:

var invertirDigitos = n => {
if (!Number.isInteger(n)) throw "El número debe ser entero";
let ni = 0;
while (n!=0) {
ni= ni*10+n%10;
n = Math.quot(n,10);
}
return ni;
};

Con el cual se obtienen los resultados esperados:

invertirDigitos(12345)

invertirDigitos(-65432)

invertirDigitos(8)

invertirDigitos(23.456)

Número sin su primer dígito

En este ejemplo, se programa un método que devuelve el número desde el cual es llamado, sin su primer dígito. Así si el método es llamado desde el número 12345, el método devuelve el número 2345.

Si se toma en cuenta que el residuo de 12345 entre 10000 (1e4) es 2345 (12345%10000 = 2345) y que, igualmente, el residuo de 798324 entre 100000 (1e5), es 98324 (798324%100000 = 98324), se concluye que para obtener el número sin su primer dígito, se debe calcular el residuo de ese número entre 1×10^{número de dígitos del número-1}.

Por lo tanto, el problema se reduce a calcular el valor de 10 elevado al número de dígitos menos 1. Dicho valor: "d", puede ser calculado en un ciclo repetitivo, donde, en cada repetición del ciclo se multiplica el valor de "d" por 10 y que se repite mientras la división del número entre "d" sea mayor o igual a 10 (mientras el resultado del número entre "d" tenga más de un dígito):

gojsGraph({divi, modelo: {"class":"go.GraphLinksModel","linkFromPortIdProperty":"fromPort","linkToPortIdProperty":"toPort","nodeDataArray":[{"category":"Start","text":"spd","key":-1,"loc":"-60.00000000000007 -505.9999999999998"},{"category":"Conditional","text":"m/d>=10","key":-5,"loc":"-60.000000000000114 -278.9999999999997"},{"category":"Output","text":"n%d","key":-4,"loc":"-59.4830728086673 -138.55739932367896"},{"category":"Process","text":"d = 1","key":-2,"loc":"-60.00000000000003 -338.7999999523163"},{"category":"Start","text":"fin","key":-9,"loc":"-59.22928820530413 -85.92229869014633"},{"category":"Process","text":"d = d*10","key":-6,"loc":"-59.53032135064534 -208.4477711377669"},{"category":"Input","text":"número entero: n","key":-3,"loc":"-60 -450.2000002861023"},{"category":"Process","text":"m = abs(n)","key":-8,"loc":"-60.00000000000003 -394.7999999523163"}],"linkDataArray":[{"from":-1,"to":-3,"fromPort":"B","toPort":"T","points":[-60.00000000000008,-490.73332138061494,-60.00000000000008,-480.73332138061494,-60.00000000000008,-477.60000014305103,-60,-477.60000014305103,-60,-474.4666789054871,-60,-464.4666789054871]},{"from":-3,"to":-8,"fromPort":"B","toPort":"T","points":[-60,-435.9333216667175,-60,-425.9333216667175,-60,-424.0000001192093,-60.00000000000003,-424.0000001192093,-60.00000000000003,-422.06667857170106,-60.00000000000003,-412.06667857170106]},{"from":-8,"to":-2,"fromPort":"B","toPort":"T","points":[-60.00000000000003,-377.5333213329315,-60.00000000000003,-367.5333213329315,-60.00000000000003,-366.7999999523163,-60.00000000000003,-366.7999999523163,-60.00000000000003,-366.06667857170106,-60.00000000000003,-356.06667857170106]},{"from":-2,"to":-5,"fromPort":"B","toPort":"T","points":[-60.00000000000003,-321.5333213329315,-60.00000000000003,-311.5333213329315,-60.00000000000003,-310.2833392858504,-60.000000000000114,-310.2833392858504,-60.000000000000114,-309.0333572387693,-60.000000000000114,-299.0333572387693]},{"from":-5,"to":-6,"fromPort":"B","toPort":"T","visible":true,"points":[-60.000000000000114,-258.9666427612303,-60.000000000000114,-248.96664276123028,-60.000000000000114,-242.34054625919097,-59.53032135064534,-242.34054625919097,-59.53032135064534,-235.71444975715167,-59.53032135064534,-225.71444975715167],"text":"Si"},{"from":-5,"to":-4,"fromPort":"R","toPort":"T","visible":true,"points":[1.3598480224608238,-278.9999999999998,11.359848022460824,-278.9999999999998,48,-278.9999999999998,48,-180,-59.4830728086673,-180,-59.4830728086673,-166.16853035598692,-59.4830728086673,-156.16853035598692],"text":"No"},{"from":-4,"to":-9,"fromPort":"B","toPort":"T","points":[-59.4830728086673,-125.87738498041725,-59.4830728086673,-115.87738498041725,-59.4830728086673,-113.5331811449742,-59.22928820530413,-113.5331811449742,-59.22928820530413,-111.18897730953114,-59.22928820530413,-101.18897730953114]},{"from":-6,"to":-5,"fromPort":"L","toPort":"L","points":[-94.74081634576252,-208.4477711377669,-104.74081634576252,-208.4477711377669,-146,-208.4477711377669,-146,-278.9999999999998,-131.35984802246105,-278.9999999999998,-121.35984802246105,-278.9999999999998]}]} })

Como se puede ver, en el ciclo se trabaja con el valor absoluto del número: "m", porque si el número fuera negativo la condición sería desde el principio falsa (porque cualquier número positivo es siempre mayor a uno negativo). El signo del número se recupera al devolver el resultado, porque en ese cálculo se emplea el número original "n".

El código respectivo, implementado con la estructura while, es:

function spd(n) {
if (!Number.isInteger(n)) throw "El número debe ser entero";
let m = Math.abs(n);
let d = 1;
while (m/d>=10) d *= 10;
return n%d;
};

Con el cual se obtienen los resultados esperados:

spd(12345)

spd(-45678)

spd(7)

spd(45.67)

El problema puede ser resuelto también siguiendo una lógica similar a la que permite invertir los dígitos de un número, es decir, trabajando con el cociente del número de la iteración anterior y calculando el número resultante, sumando, al resultado de la iteración anterior, el residuo del número entre 10 multiplicado por un múltiplo de 10. Ese múltiplo debe ser igual 1 en la primera iteración, 10 en la segunda, 100 en la tercera y así sucesivamente (para que el residuo sea añadido a la izquierda del resultado anterior).

El ciclo concluye cuando el valor absoluto del número es menor o igual a 10 o lo que es lo mismo, el proceso se repite mientras el valor absoluto del número es mayor a 10, tal como se puede ver en el siguiente diagrama de flujo:

Siendo el código respectivo:

function spd_b(n) { if (!Number.isInteger(n)) throw "El número debe ser entero"; let nr = 0; let m = 0.1; while (Math.abs(n)>10) { nr = nr+n%10*(m*=10); n = Math.quot(n,10); } return nr; }

Con el cual se obtienen los resultados esperados:

spd_b(12345)

spd_b(-45678)

spd_b(7)

spd_b(45.67)

Raíz cuadrada

En este ejemplo se programa un método que devuelve la raíz cuadrada del número desde el cual es llamado.

La raíz cuadrada, puede ser calculada aplicando, iterativamente, la siguiente ecuación (deducida en base al método de Newton-Raphson):

\[ x_2 = \dfrac{\left( x_1 + \dfrac{n}{x_1}\right)}{2} \]

Para resolver esta ecuación, se asume un valor inicial (x₁). Con ese valor se calcula x₂, se compara x₁ con x₂ y si son iguales, en un determinado número de dígitos, el proceso concluye, caso contrario, "x₁" toma el valor de "x₂" (x₁ = x₂) y el proceso se repite mientras x₁ y x₂ no sean iguales en un determinado número de dígitos.

Para determinar si dos números: x₁ y x₂, son iguales en "n" dígitos, debe ser verdadera (true) la siguiente expresión relacional:

\[ \left| \dfrac{x_1}{x_2}-1\right| < 1 \times 10^{-n} \]

En este caso, como el proceso se repite mientras los números no son iguales, simplemente se niega la expresión relacional (o, alternativamente, se emplea el operador relacional complementario: >=).

Dado que, para comparar los dos números, primero se debe calcular el segundo (x₂), el proceso debe repetirse por lo menos una vez, por lo tanto, la estructura más adecuada para este caso es do-while:

gojsGraph({divi, modelo: {"class":"go.GraphLinksModel","linkFromPortIdProperty":"fromPort","linkToPortIdProperty":"toPort","nodeDataArray":[{"category":"Start","text":"rCuadrada","key":-1,"loc":"-60.00000000000007 -505.9999999999998"},{"category":"Conditional","text":"abs(x1/x2-1)\n>=1e-14","key":-5,"loc":"-59.28921783243575 -174.99999999999966"},{"category":"Output","text":"x2","key":-4,"loc":"-59.12768172488509 -81.35147833983822"},{"category":"Start","text":"fin","key":-9,"loc":"-58.873897121521935 -28.71637770630562"},{"category":"Process","text":"x1 = x2","key":-6,"loc":"-59.53032135064538 -313.44777113776695"},{"category":"Input","text":"número positivo: n\nvalor inicial asumido: x2=1.1","key":-3,"loc":"-60 -450.2000002861023"},{"category":"Process","text":"x2 = (x1+n/x1)/2","key":-10,"loc":"-59.41532071091355 -255.7999999523163"},{"category":"Conditional","text":"n==0 o n==1","key":-8,"loc":"-60.00000000000014 -383.99999999999966"},{"category":"Output","text":"n","key":-12,"loc":"87.16153610755052 -232.97896365880774"}],"linkDataArray":[{"from":-1,"to":-3,"fromPort":"B","toPort":"T","points":[-60.0000000000001,-490.73332138061494,-60.0000000000001,-480.73332138061494,-60.000000000000064,-480.73332138061494,-60.000000000000064,-483.23335752487185,-60.00000000000003,-483.23335752487185,-60.00000000000003,-473.23335752487185]},{"from":-6,"to":-10,"fromPort":"B","toPort":"T","points":[-59.53032135064538,-296.1810925183822,-59.53032135064538,-286.1810925183822,-59.53032135064538,-284.6238855450416,-59.41532071091355,-284.6238855450416,-59.41532071091355,-283.0666785717011,-59.41532071091355,-273.0666785717011]},{"from":-4,"to":-9,"fromPort":"B","toPort":"T","points":[-59.12768172488509,-68.6714639965765,-59.12768172488509,-58.671463996576506,-59.12768172488509,-56.32726016113344,-58.873897121521935,-56.32726016113344,-58.873897121521935,-53.98305632569037,-58.873897121521935,-43.98305632569037]},{"from":-3,"to":-8,"fromPort":"B","toPort":"T","points":[-60.00000000000003,-427.1666430473328,-60.00000000000003,-417.1666430473328,-60.00000000000003,-415.60000014305103,-60.00000000000014,-415.60000014305103,-60.00000000000014,-414.0333572387692,-60.00000000000014,-404.0333572387692]},{"from":-8,"to":-12,"fromPort":"R","toPort":"T","visible":true,"points":[23.62837219238267,-383.99999999999966,33.62837219238267,-383.99999999999966,87.16153610755052,-383.99999999999966,87.16153610755052,-322.2950473455577,87.16153610755052,-260.59009469111567,87.16153610755052,-250.59009469111567],"text":"Si"},{"from":-8,"to":-6,"fromPort":"B","toPort":"T","visible":true,"points":[-60.00000000000014,-363.96664276123016,-60.00000000000014,-353.96664276123016,-60.00000000000014,-347.34054625919094,-59.53032135064538,-347.34054625919094,-59.53032135064538,-340.7144497571517,-59.53032135064538,-330.7144497571517],"text":"No"},{"from":-10,"to":-5,"fromPort":"B","toPort":"T","points":[-59.41532071091355,-238.5333213329316,-59.41532071091355,-228.5333213329316,-59.41532071091355,-225.55001790523517,-59.28921783243578,-225.55001790523517,-59.28921783243578,-222.5667144775387,-59.28921783243578,-212.5667144775387]},{"from":-5,"to":-4,"fromPort":"B","toPort":"T","visible":true,"points":[-59.28921783243578,-137.43328552246058,-59.28921783243578,-127.43328552246058,-59.28921783243578,-118.19794744730338,-59.12768172488509,-118.19794744730338,-59.12768172488509,-108.96260937214618,-59.12768172488509,-98.96260937214618],"text":"No"},{"from":-5,"to":-6,"fromPort":"L","toPort":"L","visible":true,"points":[-143.03482330118578,-174.99999999999966,-153.03482330118578,-174.99999999999966,-192,-174.99999999999966,-192,-313.44777113776695,-101.00251220757897,-313.44777113776695,-91.00251220757897,-313.44777113776695],"text":"Si"},{"from":-12,"to":-9,"fromPort":"B","toPort":"R","points":[87.16153610755052,-220.298949315546,87.16153610755052,-210.298949315546,87.16153610755052,-28.716377706305604,30.92358091337019,-28.716377706305604,-25.314374280810135,-28.716377706305604,-35.314374280810135,-28.716377706305604]}]} })

Como se puede ver en el diagrama, el resultado se calcula con 14 dígitos de precisión (el proceso se repite hasta que x₁ y x₂ son iguales en por lo menos 14 dígitos). Cuando el número es 0 o 1, el resultado es devuelto inmediatamente, porque la raíz cuadrada de 0 es 0 y la raíz cuadrada de 1 es 1, es decir que el resultado es el valor de "n". Observe también que, en lugar de asumir un valor inicial para "x1" (como dicta la lógica), se asume un valor inicial para "x2", porque si se asumiera un valor inicial para "x1", primero se calcularía "x2", luego "x1" tomaría el valor de "x2" (x1=x2) y se compararían esos valores, pero como ahora serían iguales, la condición sería siempre falsa y el ciclo no se repetiría nunca.

El código respectivo, es:

var raizCuadrada = function(n, x2=1.1) {
if (n<0) throw "El número debe ser positivo";
if (n==0 || n==1) return n;
let x1;
do {
x1 = x2;
x2 = (x1+n/x1)/2;
} while(Math.abs(x1/x2-1)>=1e-14);
return x2;
};

Donde el valor inicial asumido ("x2"), se recibe como un parámetro de la función y (en concordancia con el diagrama de flujo) tiene un valor inicial por defecto igual a 1.1.

Llamando al método con algunos valores de prueba, se obtiene:

raizCuadrada(2)

raizCuadrada(12.34)

raizCuadrada(183)

raizCuadrada(567, 20.1)

raizCuadrada(-32.43)

En el penúltimo cálculo (sólo como ejemplo), se manda un valor inicial más próximo a la solución (20.1) en lugar del valor por defecto (1.1), por lo que (aunque no se nota al ejecutar el código), el resultado es encontrado en un menor número de iteraciones.

Como se dijo, cuando se trabaja con estructuras iterativas, se debe tener especial cuidado en verificar que la condición del ciclo sea falsa en algún momento, para garantizar que el ciclo concluya, porque, de no ser así, el ciclo se repetiría indefinidamente (ciclo infinito) bloqueando la página y obligando a su cierre.

Como se verá en el siguiente capítulo, para seguir la lógica natural, algo que es aconsejable en todo algoritmo, en lugar de modificar el orden (como sucede en este ejemplo), se modifica la estructura de control.

Estructura "for" (para)

El algoritmo de esta estructura es el siguiente:

gojsGraph({divi, modelo: {"class":"go.GraphLinksModel","linkFromPortIdProperty":"fromPort","linkToPortIdProperty":"toPort","nodeDataArray":[{"category":"For","text":"condición","key":-7,"loc":"-331 -366"},{"category":"Connector","text":"...","key":-9,"loc":"-330.66128284365425 -481.8306414218272"},{"category":"Connector","text":"...","key":-11,"loc":"-330.48113427607365 -227.26482979932814"},{"category":"Process","text":"instrucciones","key":-12,"loc":"-330.51030195035906 -292.8850396771728"},{"category":"Process","text":"inicialización","key":-5,"loc":"-330.94564206155894 -424.44777113776695"},{"category":"Process","text":"incremento","key":-6,"loc":"-447.20083360517805 -366.1182833922996"}],"linkDataArray":[{"from":-9,"to":-5,"fromPort":"B","toPort":"T","points":[-330.66128284365425,-467.1348876145819,-330.66128284365425,-457.1348876145819,-330.66128284365425,-454.4246686858668,-330.94564206155894,-454.4246686858668,-330.94564206155894,-451.7144497571517,-330.94564206155894,-441.7144497571517]},{"from":-5,"to":-7,"fromPort":"B","toPort":"T","points":[-330.94564206155894,-407.1810925183822,-330.94564206155894,-397.1810925183822,-330.94564206155894,-393.8822203963066,-331,-393.8822203963066,-331,-390.58334827423096,-331,-380.58334827423096]},{"from":-7,"to":-12,"fromPort":"B","toPort":"T","visible":true,"points":[-331,-348.91665172576904,-331,-338.91665172576904,-331,-329.53418501116334,-330.5103019503591,-329.53418501116334,-330.5103019503591,-320.15171829655765,-330.5103019503591,-310.15171829655765],"text":"Si"},{"from":-12,"to":-6,"fromPort":"L","toPort":"B","points":[-381.8027824191091,-292.88503967717287,-391.8027824191091,-292.88503967717287,-447.20083360517805,-292.88503967717287,-447.20083360517805,-315.8683222250438,-447.20083360517805,-338.8516047729148,-447.20083360517805,-348.8516047729148]},{"from":-6,"to":-7,"fromPort":"R","toPort":"L","points":[-401.7869847282249,-366.1182833922996,-391.7869847282249,-366.1182833922996,-389.6427561275402,-366.1182833922996,-389.6427561275402,-366,-387.49852752685547,-366,-377.49852752685547,-366]},{"from":-7,"to":-11,"fromPort":"R","toPort":"T","visible":true,"points":[-284.50147247314453,-366,-274.50147247314453,-365.4496644776554,-244.75865009681382,-365.4496644776554,-244.75865009681382,-263.4140350127294,-330.4811342760736,-263.4140350127294,-330.4811342760736,-251.9605836065734,-330.4811342760736,-241.9605836065734],"text":"No"}]} })

Es decir, primero se ejecutan las instrucciones correspondientes a la inicialización, donde por lo general se asignan valores iniciales a los contadores del ciclo, luego se evalúa la condición y si es verdadera (Si), se ejecutan las instrucciones del ciclo, luego se ejecutan las instrucciones correspondientes al incremento, donde por lo general se incrementa o disminuye el valor de los contadores del ciclo y se vuelve a evaluar la condición del ciclo, prosiguiendo de esa manera mientras la condición es verdadera. Cuando la condición es falsa, el ciclo concluye y el programa continúa con las instrucciones restantes.

La sintaxis de esta estructura, en Javascript, es:

for (inicialización; condición; incremento) { instrucciones; }

Si el sector de inicialización o de incremento (o inclusive el de la condición) constan de más de una instrucción, dichas instrucciones deben estar separadas con comas, no puntos y comas (al igual que ocurre con el operador ?).

Si bien la lógica de esta estructura puede ser codificada con la estructura while, se prefiere la estructura for, porque es más compacta que la estructura while.

Por ejemplo, la generación de los números impares comprendidos entre 5 y 17, se resuelve de manera más compacta con la estructura for:

Siendo el código respectivo:

for (let i=5; i<=17; i+=2) print("i = "+i);

Ejemplos

Sumatoria de los primeros "n" números pares

En este ejemplo se programa el método que devuelve la sumatoria de los primeros "n" números pares, siendo "n" el número desde el cual se llama al método.

El algoritmo, es:

Siendo el código respectivo:

function sumPares(n) {
if (!Number.isInteger(n)) throw "El número debe ser entero";
if (n<0) throw "El número debe ser positivo";
let s = 0;
for(let i=2; i<=n; i+=2) s+=i;
return s;
};

Que devuelve los resultados esperados:

sumPares(0)

sumPares(5)

sumPares(12)

sumPares(7.3)

sumPares(-10)

Número primo

En este ejemplo se programa un método que determina si el número entero desde el cual es llamado, es (true) o no (false) un número primo.

Un número es primo si sólo es divisible entre 1 y entre sí mismo, excepto el número 1 que, por definición, no es primo. Por lo tanto, para determinar si un número es o no primo, se debe comprobar que no sea divisible entre 2, 3, .., etc., hasta la mitad del número que se está probando (pues ningún número es divisible entre un número mayor a su mitad o más exactamente mayor a su raíz cuadrada).

Si el número es divisible entre cualquiera número (que no sea 1 o sí mismo), se sabe que no es primo y en consecuencia, el proceso debe concluir. Caso contrario, se sabe que el número es primo.

El diagrama de flujo que resuelve el problema, es:

gojsGraph({divi, modelo: {"class":"go.GraphLinksModel","linkFromPortIdProperty":"fromPort","linkToPortIdProperty":"toPort","nodeDataArray":[{"category":"For","text":"i<=n/2","key":-7,"loc":"-427.3523210262653 -251.74957680009345"},{"category":"Process","text":"i = 2","key":-5,"loc":"-427.2979630878241 -310.19734793786057"},{"category":"Process","text":"i = i+1","key":-6,"loc":"-520.9361724042823 -251.52601032130667"},{"category":"Start","text":"esPrimo","key":-1,"loc":"-331.9273938191614 -469.6705122545327"},{"category":"Start","text":"fin","key":-8,"loc":"-331.7239720852899 -67.97054242097477"},{"category":"Input","text":"número entero positivo: n","key":-3,"loc":"-332 -416"},{"category":"Output","text":"false","key":-11,"loc":"-428.0848441301117 -104.04849786319676"},{"category":"Conditional","text":"n<2","key":-4,"loc":"-331.8427253205205 -354.2077360576578"},{"category":"Output","text":"false","key":-12,"loc":"-206.67683936202894 -203.3231606379713"},{"category":"Conditional","text":"n%i==0","key":-10,"loc":"-427.63142412166815 -178.3231606379713"},{"category":"Output","text":"true","key":-13,"loc":"-331.91548555193884 -139.3231606379713"}],"linkDataArray":[{"from":-5,"to":-7,"fromPort":"B","toPort":"T","points":[-427.2979630878241,-292.9306693184758,-427.2979630878241,-282.9306693184758,-427.2979630878241,-279.6317971964001,-427.35232102626526,-279.6317971964001,-427.35232102626526,-276.3329250743244,-427.35232102626526,-266.3329250743244]},{"from":-6,"to":-7,"fromPort":"R","toPort":"L","points":[-493.09966269969243,-251.52601032130667,-483.09966269969243,-251.52601032130667,-478.6961037099027,-251.52601032130667,-478.6961037099027,-251.74957680009345,-474.2925447201129,-251.74957680009345,-464.2925447201129,-251.74957680009345]},{"from":-1,"to":-3,"fromPort":"B","toPort":"T","points":[-331.92739381916147,-454.40383363514786,-331.92739381916147,-444.40383363514786,-331.92739381916147,-442.33525612726635,-332,-442.33525612726635,-332,-440.2666786193848,-332,-430.2666786193848]},{"from":-3,"to":-4,"fromPort":"B","toPort":"T","points":[-332,-401.7333213806152,-332,-391.7333213806152,-332,-387.98720733852133,-331.8427253205205,-387.98720733852133,-331.8427253205205,-384.2410932964274,-331.8427253205205,-374.2410932964274]},{"from":-4,"to":-12,"fromPort":"R","toPort":"T","visible":true,"points":[-304.1861854035283,-354.2077360576578,-294.1861854035283,-354.2077360576578,-206.67683936202894,-354.2077360576578,-206.67683936202894,-292.5710138639686,-206.67683936202894,-230.93429167027926,-206.67683936202894,-220.93429167027926],"text":"Si"},{"from":-4,"to":-5,"fromPort":"L","toPort":"T","visible":true,"points":[-359.4992652375127,-354.2077360576578,-369.4992652375127,-354.2077360576578,-427.2979630878241,-354.2077360576578,-427.2979630878241,-345.8358813074516,-427.2979630878241,-337.46402655724535,-427.2979630878241,-327.46402655724535],"text":"No"},{"from":-7,"to":-10,"fromPort":"B","toPort":"T","visible":true,"points":[-427.35232102626526,-237.1662285258625,-427.35232102626526,-227.1662285258625,-427.35232102626526,-217.76137320130167,-427.63142412166815,-217.76137320130167,-427.63142412166815,-208.35651787674084,-427.63142412166815,-198.35651787674084],"text":"Si"},{"from":-10,"to":-6,"fromPort":"L","toPort":"B","visible":true,"points":[-479.06645219784,-178.3231606379713,-489.06645219784,-178.3231606379713,-520.9361724042823,-178.3231606379713,-520.9361724042823,-201.29124616994662,-520.9361724042823,-224.25933170192192,-520.9361724042823,-234.25933170192192],"text":"No"},{"from":-10,"to":-11,"fromPort":"B","toPort":"T","visible":true,"points":[-427.63142412166815,-158.2898033992018,-427.63142412166815,-148.2898033992018,-427.63142412166815,-139.97471614735326,-428.0848441301117,-139.97471614735326,-428.0848441301117,-131.6596288955047,-428.0848441301117,-121.65962889550471],"text":"Si"},{"from":-7,"to":-13,"fromPort":"R","toPort":"T","visible":true,"points":[-390.4120973324176,-251.74957680009345,-380.4120973324176,-251.74957680009345,-331.91548555193884,-251.74957680009345,-331.91548555193884,-209.34193423518636,-331.91548555193884,-166.93429167027926,-331.91548555193884,-156.93429167027926],"text":"No"},{"from":-12,"to":-8,"fromPort":"B","toPort":"R","points":[-206.67683936202894,-190.6431462947096,-206.67683936202894,-180.6431462947096,-206.67683936202894,-67.97054242097477,-252.42064430330345,-67.97054242097477,-298.16444924457795,-67.97054242097477,-308.16444924457795,-67.97054242097477]},{"from":-11,"to":-8,"fromPort":"B","toPort":"L","points":[-428.0848441301117,-91.36848351993504,-428.0848441301117,-81.36848351993504,-428.0848441301117,-67.97054242097477,-396.6841695280566,-67.97054242097477,-365.28349492600154,-67.97054242097477,-355.28349492600154,-67.97054242097477]},{"from":-13,"to":-8,"fromPort":"B","toPort":"T","points":[-331.91548555193884,-126.6431462947096,-331.91548555193884,-116.6431462947096,-331.91548555193884,-104.94018366753457,-331.72397208528974,-104.94018366753457,-331.72397208528974,-93.23722104035953,-331.72397208528974,-83.23722104035953]}]} })

El código respectivo, es:

var esPrimo = n => {
if (!Number.isInteger(n)) throw "El número debe ser entero";
if (n<0) throw "El número debe ser positivo";
if (n<2) return false;
for (let i=2; i<=n/2; i++)
if (n%i==0) return false;
return true;
};

Con el cual se obtienen los resultados esperados:

esPrimo(7)

esPrimo(8)

esPrimo(21)

esPrimo(157)

esPrimo(159)

esPrimo(67.32)

esPrimo(-121)

Fibonacci de un número

En este ejemplo se programa un método que devuelve el Fibonacci del número entero positivo desde el cual es llamado.

La ecuación de definición del Fibonacci, es:

\[ \begin{aligned} F_n &= F_{n-1}+F_{n-2}\\[2mm] F_1 &= 1\\[2mm] F_2 &= 1 \end{aligned} \]

Dado que, por definición, se conoce el valor del primer y segundo Fibonacci, el cálculo comienza a partir del tercero, es decir, se calcula el Fibonacci de 3 (F₂+F₁), luego el de 4 (F₃+F₂) y así sucesivamente. Por ejemplo, con las siguientes operaciones se calcula el Fibonacci de 8:

\[ \begin{alignedat}{1} F3 &= F2+F1 = 1+1 = 2\\ F4 &= F3+F2 = 2+1 = 3\\ F5 &= F4+F3 = 3+2 = 5\\ F6 &= F5+F4 = 5+3 = 8\\ F7 &= F6+F5 = 8+5 = 13\\ F8 &= F7+F6 = 13+8 = 21 \end{alignedat} \]

Entonces, en un ciclo que va desde 3 hasta el número ("n") cuyo Fibonacci se quiere calcular, se calculan sucesivamente (en cada iteración) los Fibonacci de 3, 4, 5, ..., hasta "n". Pero como la función devuelve únicamente el último Fibonacci calculado (El Fibonacci de "n") sólo es necesario guardar ese valor y conservar los dos anteriores (haciendo un intercambio de variables) como se muestra en los siguientes operaciones, donde se vuelve a calcular el Fibonacci de 8, pero conservando sólo los dos últimos valores:

\[ \begin{array}{l | l | l} F3 = F2+F1 = 1+1 = 2 & F1=F2=1 & F2=F3=2\\ F4 = F2+F1 = 2+1 = 3 & F1=F2=2 & F2=F3=3\\ F5 = F2+F1 = 3+2 = 5 & F1=F2=3 & F2=F3=5\\ F6 = F2+F1 = 5+3 = 8 & F1=F2=5 & F2=F3=8\\ F7 = F2+F1 = 8+5 = 13 & F1=F2=8 & F2=F3=13\\ F8 = F2+F1 = 13+8 = 21 \end{array} \]

El algoritmo, en forma de diagrama de flujo, es:

gojsGraph({divi, modelo: {"class":"go.GraphLinksModel","linkFromPortIdProperty":"fromPort","linkToPortIdProperty":"toPort","nodeDataArray":[{"category":"For","text":"i<=n","key":-7,"loc":"-427.35232102626526 -143.7495768000935"},{"category":"Process","text":"i = 3","key":-5,"loc":"-427.297963087824 -202.19734793786046"},{"category":"Process","text":"i = i+1","key":-6,"loc":"-520.9361724042825 -143.52601032130673"},{"category":"Start","text":"fibonacci","key":-1,"loc":"-331.9273938191614 -469.6705122545327"},{"category":"Start","text":"fin","key":-8,"loc":"-331.72397208528986 40.029457579025205"},{"category":"Input","text":"número entero positivo: n","key":-3,"loc":"-332 -416"},{"category":"Conditional","text":"n<3","key":-4,"loc":"-331.8427253205205 -354.2077360576578"},{"category":"Output","text":"1","key":-12,"loc":"-203.67683936202897 -162.32316063797137"},{"category":"Output","text":"f3","key":-13,"loc":"-331.91548555193907 -31.323160637971228"},{"category":"Process","text":"f1 = 1","key":-14,"loc":"-427.297963087824 -317.19734793786046"},{"category":"Process","text":"f2= 1","key":-15,"loc":"-427.297963087824 -259.19734793786046"},{"category":"Process","text":"f3 = f2+f1","key":-16,"loc":"-427.297963087824 -77.19734793786046"},{"category":"Process","text":"f1 = f2","key":-17,"loc":"-427.297963087824 -21.197347937860457"},{"category":"Process","text":"f2 = f3","key":-18,"loc":"-427.297963087824 30.802652062139543"}],"linkDataArray":[{"from":-5,"to":-7,"fromPort":"B","toPort":"T","points":[-427.297963087824,-184.9306693184757,-427.297963087824,-174.9306693184757,-427.297963087824,-171.6317971964001,-427.35232102626526,-171.6317971964001,-427.35232102626526,-168.33292507432446,-427.35232102626526,-158.33292507432446]},{"from":-6,"to":-7,"fromPort":"R","toPort":"L","points":[-493.09966269969243,-143.52601032130667,-483.09966269969243,-143.52601032130667,-475.20336307879916,-143.52601032130667,-475.20336307879916,-143.7495768000935,-467.3070634579059,-143.7495768000935,-457.3070634579059,-143.7495768000935]},{"from":-1,"to":-3,"fromPort":"B","toPort":"T","points":[-331.9273938191614,-454.4038336351482,-331.9273938191614,-444.4038336351482,-331.9273938191614,-442.33525612726646,-332,-442.33525612726646,-332,-440.2666786193848,-332,-430.2666786193848]},{"from":-3,"to":-4,"fromPort":"B","toPort":"T","points":[-332,-401.7333213806152,-332,-391.7333213806152,-332,-387.98720733852133,-331.8427253205205,-387.98720733852133,-331.8427253205205,-384.2410932964274,-331.8427253205205,-374.2410932964274]},{"from":-4,"to":-12,"fromPort":"R","toPort":"T","visible":true,"points":[-304.1861854035281,-354.2077360576579,-294.1861854035281,-354.2077360576579,-203.67683936202897,-354.2077360576579,-203.67683936202897,-272.0710138639686,-203.67683936202897,-189.93429167027932,-203.67683936202897,-179.93429167027932],"text":"Si"},{"from":-7,"to":-13,"fromPort":"R","toPort":"T","visible":true,"points":[-397.39757859462463,-143.7495768000935,-387.39757859462463,-143.7495768000935,-331.91548555193907,-143.7495768000935,-331.91548555193907,-101.34193423518634,-331.91548555193907,-58.93429167027918,-331.91548555193907,-48.93429167027918],"text":"No"},{"from":-12,"to":-8,"fromPort":"B","toPort":"R","points":[-203.67683936202897,-149.64314629470965,-203.67683936202897,-139.64314629470965,-203.67683936202897,40.029457579025234,-250.92064430330356,40.029457579025234,-298.1644492445781,40.029457579025234,-308.1644492445781,40.029457579025234]},{"from":-13,"to":-8,"fromPort":"B","toPort":"T","points":[-331.91548555193907,-18.643146294709513,-331.91548555193907,-8.643146294709513,-331.91548555193907,3.059816332465479,-331.7239720852899,3.059816332465479,-331.7239720852899,14.762778959640471,-331.7239720852899,24.76277895964047]},{"from":-15,"to":-5,"fromPort":"B","toPort":"T","points":[-427.297963087824,-241.9306693184757,-427.297963087824,-231.9306693184757,-427.297963087824,-230.69734793786046,-427.297963087824,-230.69734793786046,-427.297963087824,-229.46402655724523,-427.297963087824,-219.46402655724523]},{"from":-14,"to":-15,"fromPort":"B","toPort":"T","points":[-427.297963087824,-299.9306693184757,-427.297963087824,-289.9306693184757,-427.297963087824,-288.19734793786046,-427.297963087824,-288.19734793786046,-427.297963087824,-286.46402655724523,-427.297963087824,-276.46402655724523]},{"from":-4,"to":-14,"fromPort":"L","toPort":"T","visible":true,"points":[-359.4992652375125,-354.2077360576579,-369.4992652375125,-354.2077360576579,-427.297963087824,-354.2077360576579,-427.297963087824,-349.3358813074516,-427.297963087824,-344.46402655724523,-427.297963087824,-334.46402655724523],"text":"No"},{"from":-7,"to":-16,"fromPort":"B","toPort":"T","visible":true,"points":[-427.35232102626526,-129.16622852586255,-427.35232102626526,-119.16622852586255,-427.35232102626526,-111.81512754155389,-427.297963087824,-111.81512754155389,-427.297963087824,-104.46402655724523,-427.297963087824,-94.46402655724523],"text":"Si"},{"from":-16,"to":-17,"fromPort":"B","toPort":"T","points":[-427.297963087824,-59.93066931847571,-427.297963087824,-49.93066931847571,-427.297963087824,-49.197347937860464,-427.297963087824,-49.197347937860464,-427.297963087824,-48.46402655724522,-427.297963087824,-38.46402655724522]},{"from":-17,"to":-18,"fromPort":"B","toPort":"T","points":[-427.297963087824,-3.9306693184756867,-427.297963087824,6.069330681524313,-427.297963087824,6.069330681524313,-427.297963087824,3.5359734427547806,-427.297963087824,3.5359734427547806,-427.297963087824,13.53597344275478]},{"from":-18,"to":-6,"fromPort":"L","toPort":"B","points":[-456.3219422748357,30.802652062139547,-466.3219422748357,30.802652062139547,-520.9361724042823,30.802652062139547,-520.9361724042823,-42.72833981989119,-520.9361724042823,-116.25933170192192,-520.9361724042823,-126.25933170192192]}]} })

Siendo el código respectivo:

function fibonacci(n) {
if (!Number.isInteger(n)) throw "El número debe ser entero";
if (n<=0) throw "El número debe ser mayor a cero";
if (n<3) return 1;
let f3, f1=1, f2=1;
for (let i=3; i<=n; i++) {
f3 = f2+f1;
f1 = f2;
f2 = f3;
}
return f3;
};

Con el cual se obtienen los resultados esperados:

fibonacci(5)

fibonacci(8)

fibonacci(15)

fibonacci(25)

fibonacci(75)

fibonacci(4.56)

fibonacci(0)

fibonacci(-34)

Legendre enésimo de un número

En este ejemplo se programa un método que devuelve el legendre enésimo (n), del número real "x" desde el cual es llamado.

La ecuación de definición del Legendre, es:

\[ \begin{aligned} \text{Le}_n(x) &= \left( 2-\dfrac{1}{n}\right)\cdot x\cdot \text{Le}_{n-1}(x)-\left( 1-\dfrac{1}{n}\right)\cdot\text{Le}_{n-2}(x)\\ \text{Le}_0(x) &= 1\\ \text{Le}_1(x) &= x \end{aligned} \]

Aunque puede no ser evidente a primera vista, el algoritmo que resuelve este problema es esencialmente el mismo que el del Fibonacci, excepto que, en la ecuación se tiene una variable adicional (el número real x desde el cual se llama al método) y que el orden (el número entero n) es parte de la ecuación de definición.

En un ciclo que va desde 2 hasta el número entero "n" (el orden), se calcula, en cada iteración, los Legendre de 2, 3, 4, etc, hasta llegar al Legendre "n" que se quiere calcular y al igual que en el Fibonacci, sólo se conserva el último valor calculado y los dos anteriores.

El algoritmo que resuelve el problema, es:

gojsGraph({divi, modelo: {"class":"go.GraphLinksModel","linkFromPortIdProperty":"fromPort","linkToPortIdProperty":"toPort","nodeDataArray":[{"category":"For","text":"i<=n","key":-7,"loc":"-494.35232102626526 -91.74957680009351"},{"category":"Process","text":"i = 2","key":-5,"loc":"-494.297963087824 -150.19734793786034"},{"category":"Process","text":"i = i+1","key":-6,"loc":"-575.936172404283 -91.52601032130667"},{"category":"Start","text":"legendre","key":-1,"loc":"-331.9273938191614 -469.6705122545327"},{"category":"Start","text":"fin","key":-8,"loc":"-331.7239720852899 92.02945757902519"},{"category":"Input","text":"número real: x\norden (entero positivo): n","key":-3,"loc":"-332 -416"},{"category":"Conditional","text":"n==0","key":-4,"loc":"-331.8427253205205 -354.2077360576578"},{"category":"Output","text":"1","key":-12,"loc":"-203.676839362029 -124.32316063797148"},{"category":"Output","text":"le2","key":-13,"loc":"-383.9154855519391 30.67683936202876"},{"category":"Process","text":"le0 = 1","key":-14,"loc":"-494.2979630878238 -265.1973479378606"},{"category":"Process","text":"le1 = x","key":-15,"loc":"-494.2979630878238 -207.19734793786063"},{"category":"Process","text":"le2 = (2-1/i)*x*le1-(1-1/i)*le0","key":-16,"loc":"-494.29796308782375 -25.197347937860457"},{"category":"Process","text":"le0= le1","key":-17,"loc":"-494.2979630878239 30.80265206213955"},{"category":"Process","text":"le1 = le2","key":-18,"loc":"-494.2979630878239 82.80265206213953"},{"category":"Conditional","text":"n==1","key":-19,"loc":"-414.8427253205203 -307.20773605765766"},{"category":"Output","text":"x","key":-20,"loc":"-331.676839362029 -124.32316063797148"}],"linkDataArray":[{"from":-5,"to":-7,"fromPort":"B","toPort":"T","points":[-494.297963087824,-132.9306693184757,-494.297963087824,-122.93066931847571,-494.297963087824,-120.88179719640009,-494.35232102626526,-120.88179719640009,-494.35232102626526,-118.83292507432446,-494.35232102626526,-108.83292507432446]},{"from":-6,"to":-7,"fromPort":"R","toPort":"L","points":[-548.0996626996927,-91.52601032130674,-538.0996626996927,-91.52601032130674,-536.2033630787993,-91.52601032130674,-536.2033630787993,-91.74957680009351,-534.3070634579059,-91.74957680009351,-524.3070634579059,-91.74957680009351]},{"from":-1,"to":-3,"fromPort":"B","toPort":"T","points":[-331.92739381916124,-454.4038336351478,-331.92739381916124,-444.4038336351478,-331.9636969095807,-444.4038336351478,-331.9636969095807,-449.0333572387693,-332.00000000000006,-449.0333572387693,-332.00000000000006,-439.0333572387693]},{"from":-3,"to":-4,"fromPort":"B","toPort":"T","points":[-332.00000000000006,-392.9666427612303,-332.00000000000006,-382.9666427612303,-331.9213626602602,-382.9666427612303,-331.9213626602602,-384.2410932964272,-331.8427253205203,-384.2410932964272,-331.8427253205203,-374.2410932964272]},{"from":-4,"to":-12,"fromPort":"R","toPort":"T","visible":true,"points":[-295.68339304512966,-354.20773605765766,-285.68339304512966,-354.20773605765766,-203.676839362029,-354.20773605765766,-203.676839362029,-253.0710138639685,-203.676839362029,-151.93429167027932,-203.676839362029,-141.93429167027932],"text":"Si"},{"from":-7,"to":-13,"fromPort":"R","toPort":"T","visible":true,"points":[-464.39757859462463,-91.74957680009351,-454.39757859462463,-91.74957680009351,-383.9154855519391,-91.74957680009351,-383.9154855519391,-44.34193423518634,-383.9154855519391,3.065708329720813,-383.9154855519391,13.065708329720813],"text":"No"},{"from":-12,"to":-8,"fromPort":"B","toPort":"R","points":[-203.676839362029,-111.64314629470965,-203.676839362029,-101.64314629470965,-203.676839362029,92.0294575790252,-250.92064430330353,92.0294575790252,-298.16444924457807,92.0294575790252,-308.16444924457807,92.0294575790252]},{"from":-13,"to":-8,"fromPort":"B","toPort":"L","points":[-383.9154855519391,43.35685370529048,-383.9154855519391,53.35685370529048,-383.9154855519391,92.0294575790252,-374.59949023897036,92.0294575790252,-365.28349492600165,92.0294575790252,-355.28349492600165,92.0294575790252]},{"from":-15,"to":-5,"fromPort":"B","toPort":"T","points":[-494.29796308782375,-189.93066931847588,-494.29796308782375,-179.93066931847588,-494.29796308782375,-178.69734793786057,-494.297963087824,-178.69734793786057,-494.297963087824,-177.46402655724523,-494.297963087824,-167.46402655724523]},{"from":-14,"to":-15,"fromPort":"B","toPort":"T","points":[-494.29796308782375,-247.93066931847588,-494.29796308782375,-237.93066931847588,-494.29796308782375,-236.19734793786063,-494.29796308782375,-236.19734793786063,-494.29796308782375,-234.4640265572454,-494.29796308782375,-224.4640265572454]},{"from":-7,"to":-16,"fromPort":"B","toPort":"T","visible":true,"points":[-494.35232102626526,-74.66622852586255,-494.35232102626526,-64.66622852586255,-494.35232102626526,-58.565127541553885,-494.29796308782375,-58.565127541553885,-494.29796308782375,-52.46402655724522,-494.29796308782375,-42.46402655724522],"text":"Si"},{"from":-16,"to":-17,"fromPort":"B","toPort":"T","points":[-494.29796308782375,-7.930669318475687,-494.29796308782375,2.0693306815243133,-494.29796308782375,2.8026520621395488,-494.297963087824,2.8026520621395488,-494.297963087824,3.535973442754784,-494.297963087824,13.535973442754784]},{"from":-17,"to":-18,"fromPort":"B","toPort":"T","points":[-494.297963087824,48.06933068152432,-494.297963087824,58.06933068152432,-494.297963087824,58.06933068152432,-494.297963087824,55.535973442754766,-494.297963087824,55.535973442754766,-494.297963087824,65.53597344275477]},{"from":-18,"to":-6,"fromPort":"L","toPort":"L","points":[-529.8163117816716,82.80265206213953,-539.8163117816716,82.80265206213953,-632,82.80265206213953,-632,-91.52601032130674,-613.7726821088723,-91.52601032130674,-603.7726821088723,-91.52601032130674]},{"from":-4,"to":-19,"fromPort":"L","toPort":"T","visible":true,"points":[-368.0020575959109,-354.20773605765766,-378.0020575959109,-354.20773605765766,-414.8427253205203,-354.20773605765766,-414.8427253205203,-345.72441467704243,-414.8427253205203,-337.2410932964272,-414.8427253205203,-327.2410932964272],"text":"No"},{"from":-19,"to":-20,"fromPort":"R","toPort":"T","visible":true,"points":[-378.68339304512966,-307.20773605765766,-368.68339304512966,-307.20773605765766,-331.676839362029,-307.20773605765766,-331.676839362029,-229.57101386396855,-331.676839362029,-151.93429167027944,-331.676839362029,-141.93429167027944],"text":"Si"},{"from":-19,"to":-14,"fromPort":"L","toPort":"T","visible":true,"points":[-451.0020575959109,-307.20773605765766,-461.0020575959109,-307.20773605765766,-494.29796308782375,-307.20773605765766,-494.29796308782375,-299.83588130745153,-494.29796308782375,-292.4640265572454,-494.29796308782375,-282.4640265572454],"text":"No"},{"from":-20,"to":-8,"fromPort":"B","toPort":"T","points":[-331.676839362029,-111.64314629470977,-331.676839362029,-101.64314629470977,-331.676839362029,-17.44018366753466,-331.72397208528986,-17.44018366753466,-331.72397208528986,66.76277895964044,-331.72397208528986,76.76277895964044]}]} })

Observe que, al escribir la fórmula, se emplea la variable "i", no "n", porque "n" es una constante y corresponde el límite superior de "i". El valor de "i" (es es el valor de "n" en la fórmula) incrementa, de uno en uno, desde 2 hasta que es igual a "n".

El código respectivo, es:

function legendre(x, n) {
if (!Number.isInteger(n)) throw "El número debe ser entero";
if (n<0) throw "El número debe ser positivo";
if (n==0) return 1;
if (n==1) return x;
let le2, le0=1, le1=x;
for (let i=2; i<=n; i++) {
le2 = (2-1/i)*x*le1-(1-1/i)*le0;
le0 = le1;
le1 = le2;
}
return le2;
};

Con el cual se obtienen los resultados esperados:

legendre(1.3, 2)

legendre(1.5, 3)

legendre(3.9, 7)

legendre(2.1, 0)

legendre(13.1, 1)

legendre(6.1, 4.5)

legendre(1.1, -3)