...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 
)
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 
, 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 
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). 
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...