Lexico
...el poder de lo simple...
Marzo.25.2012
Estudiemos aquí sobre algoritmos partiendo de lo trivial para afirmar los conceptos y lentamente adicionando complejidad para ganar habilidad. (Se sugiere leer primero sobre conceptos básicos aquí y tener disponible en su máquina el compilador Lexico para probar los algoritmos).

...Y qué es un algoritmo...?

No es más que un grupo de acciones o procedimiento que al ser realizadas por una máquina o una persona producen mecánicamente resultados. Es pensamiento representado con símbolos. A quien diseña el algoritmo se le llama programador y realizar sus acciones prescritas se llama ejecutar el algoritmo.

Bajo el paradigma de la programación orientada a objetos recibe el nombre de comportamiento. Es una tarea, procedimiento o función que se activa con un mensaje. Un algoritmo representa un proceso o comportamiento, es decir, "es una de las cosas que sabe hacer" el objeto.

Al diseñar un algoritmo se debe ser muy cuidadoso(a): Algunos de ellos necesitan datos provenientes de su exterior (serán entrados por algún medio como el teclado en el futuro cuando se ejecute el algoritmo) y otros no (sus datos iniciales son escritos directamente en el algoritmo como objetos constantes ya conocidos). Siempre debe haber al menos un resultado emitido hacia su exterior. Todas las acciones deben escribirse explícitamente. Debe garantizarse que su ejecución
siempre termine en algún instante. Todas las acciones deben ser claras y posibles.

Como aprender a programar es incentivar una habilidad en el uso de conocimientos que implican procesos, a diferencia de los conocimientos declarativos o información textual, no es tan importante la memoria pues no se trata de repetir las cosas a manera de una enciclopedia sino de crear soluciones a problemas cada vez diferentes. Importa más el análisis y la síntesis que la memoria, importa más crear que repetir, les parece ?

Entonces podría concluirse que para ganar conocimientos la forma de estudiar depende del tipo de contenidos: en el caso de información declarativa bastará con apropiársela mediante la lectura y la relflexión pero en el caso de información procedimental se inicia con la lectura y la 
relflexión de los conceptos pero debe enfatizarse en la experimentación, es decir la acción que transfiera los conocimientos a otras áreas y la reflexión. Tenga a mano el compilador Lexico para que pueda fácilmente verificar los efectos de su pensamiento, base para trazarse nuevos retos.

Ganar habilidad implica que debe trabajarse un poco diariamente. Improbable aprende a nadar en 10 minutos. Improbable aprende a nadar solo leyendo un manual explicatorio. Hay que hacer. Hay que reflexionar, especificar el problema, analizar las viejas construcciones, representarlo, sintetizar las nuevas construcciones, verificar, contrastar, reflexionar... Es la vía para lentamente convertirse en un hacker que construye y diferenciarse del aprendiz de dos trucos y ser un cracker que destruye.



Que tal si empezamos definiendo un ambiente de cómputo como marco conceptual dentro del cual operarán los algoritmos ?.
Sí !, es importante tener claridad  sobre el escenario donde funcionarán las ideas plasmadas en un algoritmo !

Recomendación: en la medida que vaya leyendo, vaya dibujando un esquema con los elementos y las relaciones. Cuando termine de leer pula el dibujo y tendrá un marco de referencia claro o mapa conceptual sobre la máquina.

Digamos que la máquina está compuesta de 3 partes interiores y otras 3 exteriores.

A las internas las llamaremos CPU o unidad central de proceso compuesta por tres entidades:

La memoria principal o RAM (Ej. chips SIMM). 
Esta memoria es volátil o sea que cuando se suspende la energía a la máquina o termina de funcionar el programa se pierde el control de la información almacenada temporalmente por él. Ésta memoria permite conservar temporalmente información segmentada en diferentes zonas identificadas para poder ser discriminadas en su uso. A tales unidades se les lama objetos y pueden representar internamente la información de dos formas: los algoritmos o estructuras lógicas que llamaremos comportamientos del objeto (lo que sabe hacer) y los datos o estructuras de representación que llamaremos atributos del objeto (lo que es o el estado en que se encuentra). Unos dirán cuales son las operaciones que pueden hacerse y en cual momento y los otros contendrán información con la cual se operará. 

El procesador (Ej. un pentium 4) compuesto por cientos de circuitos diferentes cada uno encargado de efectuar un tipo de operación básica cuando los algoritmos así lo ordenen y con los atributos que indiquen.

La unidad de control lógico (Ej. el sistema operativo) compuesta por millones de instrucciones agrupadas en tareas específicas, es decir son los algoritmos que gobiernan las máquinas. Esta gran máquina es la única intangible o no física y debe residir en la memoria principal para poder tener contacto con el resto del computador que es tangible o físico.

Las partes externa son tres máquinas:

La unidad de entrada (Ej. el teclado) que permitirá ingresar información desde el exterior hacia el interior con destino a las zonas que se hayan dispuesto (objetos receptores) en la memoria principal.

La unidad de salida (Ej. la pantalla) que permitirá exteriorizar copia de la información residente en el interior de la máquina, concretamente en algunas zonas de ellas. Es decir, permitirá sacar copia de la información contenida en los objetos que se diga.

La unidad de entrada y salida o memoria externa no volátil (Ej. el disco duro) permitirá que alguna información persista a través del tiempo es decir que su información almacenada no desaparezca con la suspensión de la energía eléctrica o la terminación del programa.


Los primeros 
objetos que usaremos son simples, es decir son o una cantidad o caracteres textuales. Esto con el fin de entrenarnos en los procesos básicos en lógica de programación: Secuencia, decisión y ciclo mientras. Estos tipos de objetos entienden mensajes implícitos enviados para que operen aritmética y relacionalmente en el caso de las cantidades : +,-,*,/,^,<,>,<=,>=,=,<> y el pegado # y relacionalmente en el caso de los caracteres.

Posteriormente entraremos a usar objetos compuestos quienes solo entienden los mensajes para los cuales se hayan definido los comportamientos correspondientes.

Cuando un algoritmo tenga el control de la máquina (algoritmo en ejecución) podrá ocurrir flujo (tránsito de copia) de información así (si Ud. está dibujando, el flujo puede representarlo con una flecha, emblema universal que se intuye como dirección o sentido):

Desde el exterior hacia el interior (hacia zonas de la RAM). Lo diremos con entre. Ej.

entre a,b,c

(se estarán pidiendo 3 datos que serán recibidos por los objetos alterables a, b y c respectivamente, en ese orden, con la consecuente pérdida de la información anteriormente existente en ellos).

Desde el interior (desde algunas zonas de la RAM) hacia el exterior. Se dirá con muestre. Ej.

muestre r,s

(se estarán mostrando 2 datos, copias de lo existente en los objetos r y s en ese orden).

Cuando se desee evaluar una expresión (mezcla de operandos y operadores que expresan sintéticamente un pequeño algoritmo tal como se hace en álgebra) simplemente se escribe utilizando paréntesis para priorizar las operaciones. Se evalua de izquierda a derecha pero los paréntesis se evaluan primero y entre éstos los más internos. Ej.

(a+5)*f

(se está diciendo que tome la copia de lo que hay en el objeto variable a, que tome la copia de lo que hay en el objeto constante 5, que las lleve al procesador, que aplique el circuito sumador representado por el símbolo +, que a ese resultado parcial lo multiplique por la copia de lo que hay en el objeto variable f). Eso quiere decir que la instrucción está aún incompleta pues el computador no puede adivinar qué se va a hacer con lo calculado hasta el momento. Hay varias formas de completarla. La primera de ellas es la siguiente.

Cuando se quiere generar un flujo desde un objeto hacia otro o desde una evaluación en el procesador hacia un objeto se dice con copie en y debe indicarse el (o los) objeto(s) receptor(es) que debe(n) ser variable(s), como ya habrá deducido, para que pueda(n) ser alterado(s). Ej.

copie (a+5)*f en uno, dos, tres

(se estará diciendo que primero evalúe esa expresión en el procesador y luego ese resultado lo traslade a los objetos variables indicados)

Más adelante veremos que pueden presentarse otros flujos entre los mensajes enviados a los objetos y los correspondientes comportamientos establecidos en ellos y viceversa. También veremos los flujos entre la RAM y la unidad de EntradaYSalida que permite la persistencia de información a pesar de la suspensión de la energía o terminación del ejecución del programa.

Ejemplo 1:   (compruébelo con Lexico  y  ejercicios propuestos)
Se desea ver en pantalla los símbolos Primer ejemplo.

Qué se tiene durante la creación del algoritmo ?:
Se tiene el texto ya conocido
Primer ejemplo. Son 14 símbolos o caracteres. Entonces se debe separar RAM para que esa información exista allí antes de sacarla (es información constante pues no va a cambiar durante la futura ejecución del algoritmo) y se debe usar una instrucción que permita mostrar o desplegar una imagen de tales datos. Para definir un objeto constante en la RAM con información tipo caracteres o grupo de símbolos bastará con expresar la información encerrada dentro de un par de dobles comillas: "Primer ejemplo". Como eso es todo el algoritmo, bastará con decir que muestre la imagen de lo que reside en aquel objeto:

tarea:
    {
    muestre "Primer ejemplo"
    }

Este algoritmo, tarea o comportamiento, aunque usted no lo haya dicho, pertenece al objeto aplicación que el compilador Lexico construye automáticamente. Más adelante usted mismo lo hará cuando tenga más elementos teóricos. El par de llaves abierta-cerrada { } identifica  todo el grupo de instrucciones o la estructura secuencia que compone la tarea o algoritmo que debe ejecutarse. La forma de escribir las instrucciones es libre, por lo cual el anterior algoritmo puede describirse de muchas formas tal como las dos siguientes que ordenan lo mismo:

tarea: {
    muestre "Primer ejemplo"
                                                }
ó
tarea: { muestre "Primer ejemplo" }

Para probar los algoritmos en su máquina puede utilizar el compilador Lexico descargable desde aquí

Ejemplo 2:

Tratemos de quitar una restricción al problema anterior. Supongamos que el texto no se conoce, que lo conoce el usuario que estará al frente del computador cuando ejecuten en el futuro nuestro algoritmo en algún sitio que no sabemos. Entonces...

Qué se tiene durante el diseño del algoritmo ?
No se tiene la información concreta que se va a mostrar pero se sabe que el usuario la tendrá en ese entonces.

Cómo la mostramos ?
Pues con el verbo muestre !

...y donde estará la información ?
Pues deberá estar en la RAM !

...y cómo ha de llegar allí si no la conocemos al hacer el algoritmo ?
Pues cuando ejecuten el algoritmo éste mismo deberá pedirla al usuario.

Cómo ordenar eso ?
Con el verbo entre e indicando cual será el objeto que reciba la información. Este si va recibir información ya no podrá ser constante pues sería una contradicción sino que deberá tener la propiedad de poder cambiar, es decir será alterable, modificable o, como se dice en el argot, variable y para que él exista debemos establecerlo en la RAM con la instrucción es_un. Para ello debemos darle un nombre que permita discriminarle y establecer qué tipo de información contendrá en el futuro. Todo junto será:

tarea:
    {
    el objeto texto es un caracter
    entre texto
    muestre texto
    }

Ejemplo 3:

Nos piden hacer un algoritmo que multiplique las dos cantidades 309 y 783.

Al momento de diseñar el algoritmo ya conocemos los valores concretos por lo que podemos hacerlos parte del algoritmo como objetos constantes y para ello solo hay que mencionarlos al ordenar hacer la multiplicación en el procesador y luego debe guardarse en la RAM lo calculado. Como hay que guardar algo que no sabemos cuanto vale debemos separar espacio para un objeto alterable o variable que lo pueda recibir:

tarea:
{
el objeto resultado es una cantidad
copie 309*783 en resultado
muestre resultado
}

Ejemplo 4:

Modifiquemos el problema anterior: Calcular el producto de dos valores. Cuál restricción fue retirada ?

Esta vez desconocemos los valores concretos pero hay que hacer el algoritmo ya. No queda más remedio que ordenar que el mismo algoritmo los pida al usuario cuando se esté ejecutando en el futuro y nosotros estemos vistiendo pantalón corto en el paraiso de San Andrés Islas (recorrer la isla en 2D). Para poder recibir esos dos datos particulares en ese entonces debemos reservarles espacio variable en la RAM desde ahora mismo:

tarea:
{
los objetos valor1, valor2, resultado son cantidades
entre valor1, valor2
copie valor1*valor2 en resultado
muestre resultado
}

Los ejercicios precedentes tienen algo en común: están formados por una sucesión de instrucciones que reciben el nombre de
estructura secuencia. Usualmente una secuencia está delimitada por un par de llaves, excepto cuando la forma una sola instrucción, caso en el cual los programadores evitan el par de llaves para hacer más corto el código.


Ejemplo 5:


Es el primer número de la pareja que tiene el usuario menor que el segundo ?

Se desconocen los valores concretos y en consecuencia deben ser pedidos durante la ejecución del algoritmo. Para poderlos entrar deben establecerse previamente dos objetos variable que los puedan recibir. Luego debe instruirse al computador para que tome una decisión con base en ellos formando una expresión que al evaluarse en el procesador produzca verdadero ó falso (si ó no) y siga por la ruta consecuente. A ésto se le llama
estructura decisión lógica: Cuando al evaluarse la expresión produce como resultado interno si o verdadero se ejecutará la secuencia rotulada con el si. En caso contrario se ha ordenado ejecutar la secuencia rotulada con no (o resultado interno falso):
Código:
tarea
{
 los objetos v1, v2 son cantidades
 entre v1, v2
 es v1 < v2 ?
                  si: muestre "Sí, es menor"
                  no:muestre "No es menor"
}



Ejemplo 6:

Hagamos un algoritmo que descubra cuál de los dos valores del usuario es mayor.

De nuevo los dos valores se desconocen en el momento del diseño del algoritmo circunstancia que obliga a entrarlos en el momento de la ejecución y para ello se deben reservar previamente dos zonas variables en la RAM.

Para verificar la relación entre los dos usaremos los operadores relacionales > e = para construir expresiones lógicas (aquellas que al evaluarse producen un valor de verdad: verdadero ó falso) dentro de preguntas que orientarán a la máquina sobre el camino a seguir según lo que ocurra en ese entonces:
Código:
tarea
{
  los objetos a, b son cantidades
  entre a, b
  es a>b ?
      si: muestre a, " es mayor que ", b
      no: es a<b ?
                si: muestre b, " es mayor que ", a
                no:muestre a, " y ", b, "son iguales"
}


Ejemplo 7:

Un usuario tiene tres pares de valores y desea conocer el producto de cada uno de ellos.

Ya habíamos resuelto el algoritmo para un par. Entonces que lo ejecute tres veces !

Ejemplo 8:

El usuario quiere un algoritmo que calcule el producto a cada uno de los tres pares de valores que tiene.

En este caso debemos elaborar el algoritmo. Usaremos 9 variables (y lo referenciaremos como el algoritmo de cromagnon Smile )
tarea
{
los objetos a,b,c,d,e,f,g,h,i son cantidades
entre a,b,d,e,g,h
copie a*b en c
copie d*e en f
copie g*h en i
muestre c, f, i
}

Ejemplo 9:

El anterior algoritmo podemos mejorarlo para no usar tantas variables (creamos solo tres objetos y los reutilizamos):

tarea
{
los objetos a, b, c son cantidades
entre a, b
copie a*b en c
muestre c
entre a, b
copie a*b en c
muestre c
entre a, b
copie a*b en c
muestre c
}

Observe que hemos reutilizado los objetos cuando ya no hay peligro con destruir su contenido pues han sido mostrados.


Ejemplo 10:

El usuario nos pide que calculemos el producto a cada una de las 100 parejas de valores que tiene.

Cobrémosle un poco más pues el trabajo es muy aburrido:

Utilizando la estrategia empleada en el algoritmo cromagnon, deberíamos definir 300 objetos variables Sad, pero aún así se puede escribir !

Mejor utilicemos la segunda estrategia: reutilización de los objetos y entonces bastará con escribir el trio de instrucciones ya no 3 sino 100 veces. Molesto aún pero lo podemos hacer (seleccione, copie y pegue 299 veces).


Ejemplo 11:

El usuario ahora nos pide que le programemos el cálculo de los productos a cada una de las 3751 parejas de valores que tiene.

A esta altura ya saltan nuestra nervios (debe ser que le estamos cobrando muy poco por esa manera de pedir).

Podemos respirar profundo y escribir esas veces el trio ya famoso de instrucciones. Qué cansancio ! (....y fácilmente nos equivocaremos...y vendrá la nueva petición del usuario...y...).

La estrategia del algoritmo cromagnon ni pensarla pues aunque se puede hacer seguramente nos propiciará un infarto o al menos calambres en los dedos (sería necesario definir 11253 objetos variables y .... "algunas" cositas más ! (cuántas instrucciones tendría el algoritmo ?)

Lo mejor es cambiar de forma de programar Rolling Eyes

Para estas situaciones se usa la estructura lógica ciclo. La versión más importante de ellos es el ciclo mientras que tiene la siguiente forma:

/*aquí van las acciones_antes_del_ciclo */
mientras sea_verdad_esta_expresión_lógica haga:
                {
                grupo_de_acciones_a_repetir
                }
/* Aquí van las acciones_posteriores_(ya_fuera_del_ciclo)_que_no_se_incluyen_en_las_repeticiones */

Pero debe tenerse en cuenta algunos cuidados: en las repeticiones del ciclo o iteraciones debe incluirse al menos un objeto variable que vaya modificándose de manera que la expresión lógica que controla la próxima iteración pueda llegar a ser falsa y pueda terminar el ciclo....y antes de entrar al ciclo el objeto variable debe iniciarse apropiadamente.


Ejemplo 11 (pero en una forma decente):

Para nuestro problema de los 3751 productos se usará un objeto variable cuyo contenido vaya incrementándose de uno en uno hasta alcanzar el tope establecido. Ese objeto antes del ciclo se ha iniciado en 0 para que tenga un valor cierto la primera vez que se evalúa la expresión lógica vez < 3751. A tal objeto se le conoce como contador por la función que cumple.

tarea
{
los objetos a, b, c, vez son cantidades
copie 0 en vez
mientras vez < 3751 haga:
    {
    copie vez + 1 en vez
    entre a, b
    copie a*b en c
    muestre c
    }
}

Ejemplo 12 (generalización):

Cómo generalizar el algoritmo anterior de manera que sirva no solamente para 3751 parejas sino para cualquier número de ellas ?

tarea
{
los objetos a, b, c, num_datos,vez son cantidades
copie 0 en vez
entre num_datos
mientras vez < num_datos haga:
    {
    copie vez + 1 en vez
    copie a*b en c
    muestre c
    }
}

Podemos observar que se ha usado una variable (num_datos) para recibir durante la ejecución (y previamente al proceso de los datos) una cantidad que indicará el número de parejas que tiene el usuario. Este algoritmo ya sirve para cualquier cantidad de parejas y representa un modelo cuantitativo para controlar el proceso de un grupo de datos. Se  le dice modelo cuantitativo porque una cantidad anuncia previamente cuantos son los verdaderos datos que han de ser procesados a continuación. El usuario antes de proporcionar los datos de las parejas tiene que contar las parejas y anunciarlo al algoritmo.

Aquí vale la pena hacer dos reflexiones:

1. Será divertido para el usuario contar las parejas cuando se trate de miles de ellas ?
2. Podemos resolver éste caso general siguiendo la estrategia comagnon ?


Ejemplo 13:

Supongamos que el usuario desea conocer el producto de cada una de las parejas de valores que posee y que además nos dice que los valores son todos positivos (adiferencia del ejemplo 12 donde no especificaban ésto).

Como conocemos el dominio de los datos podemos modificar el algoritmos hecho evitándole al usuario tener que contar previamente el número de parejas para poder darlo al algoritmo que lo exige antes de iniciar con las repeticiones.

Si establecemos, por ejemplo, como convención con el usuario que para indicarnos terminar debe entrar un par de valores tal que el primero sea negativo estaremos creando una marca de fin de proceso, es decir una manera de controlar cuando suspender un ciclo de repeticiones, proporcionando al usuario más facilidad de operación (imagínense evitarle tener que contar miles de parejas). Laughing


tarea
{
los objetos a, b, c, son cantidades
entre a, b
mientras a>= 0 haga:
    {
    copie a*b en c
    muestre a,"*",b,"=",c
    entre a, b
    }
}

Observe: para evitarle contar al usuario debe haber al menos dos entradas de datos similares (entre a, b para iniciar la variable a antes del ciclo y la otra para renovación de la información dentro y al final del ciclo después de haber usado los valores previos). El algoritmo ahora tampoco tiene que contar. Desaparecen dos variables respecto al algoritmo del ejemplo 12 (num_datos y vez).

A ésta forma de controlar la llamaremos modelo cualitativo de control de un grupo de datos para oponerlo al modelo cuantitativo usado en el algoritmo del ejemplo 12. Se le dice 
modelo cualitativo porque el control se basa en una cualidad (en nuestro ejemplo los números entrados por el usuario final son positivos y la cualidad es que detectamos un valor no positivo entrado a la primera variable).


Ejemplo 14:

Se ha venido generalizando nuestro caso de estudio por la vía longitudinal. Ahora tratemos de generalizarlo transversalmente: Se desea un algoritmo que permita calcular una misma operación aritmética a cada par de valores de los que tiene el usuario.


Como se sabe que es la misma operación ésta ha de pedirse una sola vez antes del ciclo de repeticiones.

tarea
{
los objetos a, b, c, num_datos,vez son cantidades
el objeto tipo_operacion es caracter
copie 0 en vez
muestre "tipo de operacion (* / + - ^ ): "
entre tipo_operacion
entre num_datos
mientras vez < num_datos haga:
    {
    entre a,b
    es tipo_operacion="*" ? si: copie a*b en c
    es tipo_operacion="/" ? si: copie a/b en c
    es tipo_operacion="+" ? si:copie a+b en c
    es tipo_operacion="-" ? si: copie a-b en c
    es tipo_operacion="^" ? si: copie a^b en c
    muestre a,tipo_operación,b,"=",c
    copie vez + 1 en vez
    }
}
pero...


Ejemplo 15:

Se desea un algoritmo que permita calcular la operación aritmética indicada a cada par de valores de los que tiene el usuario.

En éste caso la operación no necesariamente es común a todas las parejas de valores. El usuario tendrá que entrar ya no parejas de valores sino tripletas de datos cada vez ( dos valores y el tipo de operación que se aplicará). Para que quede más legible se pedirán los tres datos en su orden: primer valor, tipo de operación y segundo valor.

tarea
{
los objetos a, b, c, num_datos,vez son cantidades
el objeto tipo_operacion es caracter
copie 0 en vez
muestre "tipo de operacion (* / + - ^ ): "
entre num_datos
mientras vez < num_datos haga:
    {
    entre a, tipo_operacion, b
    es tipo_operacion="*" ? si: copie a*b en c
    es tipo_operacion="/" ? si: copie a/b en c
    es tipo_operacion="+" ? si:copie a+b en c
    es tipo_operacion="-" ? si: copie a-b en c
    es tipo_operacion="^" ? si: copie a^b en c
    muestre a, tipo_operación, b, "=", c
    copie vez + 1 en vez
    }
}

Ejemplo 16:

Finalmente evitémosle al usuario tener que contar primero el número de parejas. Usemos el modelo cualitativo como se hizo en el ejemplo 13.

La pregunta que surge inmediatamente es cómo encontramos una cualidad que sirva de clave para terminar si no han especificado un dominio conocido para los valores ?

Es verdad, no conocemos el dominio para los valores y por ello estamos inhabilitados para establecer apriori la cualidad. Debemos utilizar es el tipo de operación que se va a aplicar pues para ella sí conocemos el domio de los datos: son solo las 5 operaciones * / + - ^ y por lo tanto establecemos el protocolo: las letras fin como tipo de operación significa que la tripleta no se procesa. Nuevamente ocurre que ya no hay necesidad de pedir la cantidad de tripletas ni de contar.

tarea
{
los objetos a, b, c son cantidades
el objeto tipo_operacion es caracter
muestre "tipo de operacion  válido(* / + - ^ ). Para terminar entre una tripleta con tipo de operacion fin"
entre a,  tipo_operacion, b
mientras tipo_operacion <> "fin" haga:
    {
    es tipo_operacion="*" ? si: copie a*b en c
    es tipo_operacion="/" ? si: copie a/b en c
    es tipo_operacion="+" ? si:copie a+b en c
    es tipo_operacion="-" ? si: copie a-b en c
    es tipo_operacion="^" ? si: copie a^b en c
    muestre a, tipo_operación, b, "=", c
    entre a, tipo_operacion, b
    }
}

Nuevamente obsérvese que existen dos entradas de datos similares: Una localizada afuera y antes del ciclo. Cumple la función de poder tener información cierta para cuando ocurra la primera evaluación de la expresión lógica que controla las iteraciones del ciclo. La segunda, localizada dentro del ciclo pero al final de la estructura secuencia cumple el papel de actualizador de datos para la próxima evaluación.

Recuerde que una habilidad se obtiene experimentando:
ciclo de planteamiento+análisis
+desarrollo+verificación+reflexión ==> Algunos ejercicios propuestos

...más tutoriales...