UNIDAD 1: EL ALGORITMO En palabras sencillas, un algoritmo es una serie de instrucciones que realizadas en orden conducen a la solucin de un problema determinado.

Tambin se puede decir que un algoritmo es la fase preliminar a escribir un programa en cualquier lenguaje de programacin, por lo que la forma de escribirlo puede ser muy personal segn el programador que lo est diseando, pero en general se debe hacer en una forma tan clara que cualquier otro programador pueda coger dicho algoritmo, entenderlo fcilmente y poderlo traducir a su lenguaje de programacin favorito. En general, hay varias formas de escribir un algoritmo en el papel: Una de ellas es el diagrama de flujo que consta de rectngulos que encierran las diferentes instrucciones y lneas que apuntan hacia la siguiente instruccin de modo que no se pierda el orden. Adems, las operaciones elementales como la entrada de datos, salida de datos, ciclos, etc. (ms adelante se explicarn) se reconocen de las dems instrucciones porque no se encierran en rectngulos sino en otra clase de figuras por lo que segn la figura en la que est encerrada la instruccin se reconoce su significado; Es muy didctico, por lo que es muy fcil de entender as ni siquiera se conozca al programador que dise el algoritmo, pero personalmente no me gusta dibujar demasiado cuadritos y lneas por lo que prefiero el pseudocodigo. En el pseudocodigo, cada instruccin es una lnea y las operaciones elementales se escriben de una forma tan clara que sea imposible que algn programador no las entienda. Aqu utilizaremos un pseudocodigo un poco personalizado, para hacer ms sencilla la explicacin. NOTA: Aunque normalmente, en el pseudocodigo, cada lnea escrita es una instruccin diferente, a veces, no se puede escribir en una sola lnea todo el contenido de una instruccin por lo que si se quiere dividir una instruccin en dos o ms lneas diferentes debern estar unidas por el signo _ al final que indicar que la lnea que est bajo esta, hace parte de la misma instruccin y no de otra diferente. Para realizar dichas instrucciones, se utilizan bsicamente Variables y Operadores. 1.1. Las variables. En general, las variables son campos en memoria que pueden almacenar cualquier tipo de informacin (nmeros, letras, frases, valores de verdad, etc. ) que pueden tener cualquier nombre, que preferiblemente debe ser mnemotcnico, es decir, que tenga relacin con l o los datos que se almacenarn en la variable. Los datos numricos se almacenan en las variables una vez en el computador en forma binaria (base 2), y los datos de caracteres como letras y frases se almacenan segn el cdigo ASCII de las letras, que es un cdigo aceptado mundialmente para representar todos los caracteres posibles (Por lo menos en muchos idiomas). Este cdigo es un numero desde 0 hasta 255 por lo que se almacena tambin en forma binaria. Los nombres de las variables deben seguir unas convenciones generales, que se crearon para evitar confusiones entre las variables y los operadores aritmticos. Estas son: 1. No pueden comenzar con nmeros. 2. No pueden contener smbolos u operadores en ninguna posicin del nombre, excepto el carcter _. 3. No pueden contener espacios. Como ejemplo aqu hay varios nombres para variables: A : Es un nombre correcto, aunque posiblemente muy poco mnemotcnico. A23: correcto. OJO5MALO : correcto. HOLA# : incorrecto, ya que tiene un smbolo dentro de su nombre. A 23 : incorrecto, porque hay un espacio dentro del nombre. A-23 : incorrecto. A_23 : correcto, ya que el carcter _ es el nico smbolo permitido para nombrar variables; se puede usar para separar palabras dentro del nombre de una misma variable. Otro ejemplo podra ser: PRIMER_NOMBRE o RADIO_CIRCULO. Una caracterstica de las variables es que son Case Sensitive, es decir que son sensibles al hecho de s el nombre fue escrito con maysculas o minsculas. Por lo que si se llam a una variable A23, dentro de las

dems instrucciones del algoritmo, cuando se haga referencia a sta variable, no podr utilizarse a23 ya que se tomaran como dos variables diferentes. Para almacenar valores a las variables se utilizar el operador igual (=). Como se dijo anteriormente, una variable puede contener nmeros, letras, frases, etc., por lo que al principio del algoritmo se deben definir que clase de datos se van a almacenar y en que variables. Declarar una variable es definir que tipo de datos se van a almacenar en dicha variable. En nuestro pseudocodigo, cuando se vaya a declarar un variable se utilizar la palabra clave DECLARAR. Cualquiera que sea el tipo de la variable, ste debe ser consistente para el resto del algoritmo, es decir, que si por ejemplo se declar que una variable va a contener datos numricos, en otra instruccin del algoritmo no se le podr asignar a dicha variable una frase o una letra. En este texto se utilizarn para declarar variables las palabras clave NUMERO, LETRA, ARREGLO, pero por el momento solo utilizaremos las primeras dos: 1. 2. NUMERO: La variable contendr datos numricos. LETRA : La variable contendr un solo carcter.

Los valores para las variables de tipo LETRA se escribirn entre (Comillas simples). Vale la pena decir que en muchos lenguajes de programacin hay una gran variedad de tipos de variables, por ejemplo si se van a almacenar nmeros grandes, pequeos, o flotantes (fraccionarios) entre muchos otros, pero para nuestro pseudocodigo solo utilizaremos estas tres palabras para declarar cualquier variable. La forma de declarar una variable es escribir la palabra DECLARAR, seguida de la palabra como y el tipo de datos que se almacenar en la variable (NUMERO o LETRA por el momento) y por ultimo el nombre de la variable. Se podrn declarar varias variables de un mismo tipo simplemente haciendo lo mismo pero en lugar de colocar un solo nombre de variable se colocar el nombre de las diferentes variables separadas por comas ( , ). Adems, a las variables se les podr asignar un valor inmediatamente en el momento de la declaracin. Esto es muy til ya que se est asegurando que las variables estn inicializadas en un valor determinado. Aqu tenemos varios ejemplos de declaraciones de variables: num ser una variable que almacenar nmeros de cualquier tipo. DECLARAR como NUMERO num Let ser una variable que almacenar letras. ( Una a la vez) DECLARAR como LETRA let num1 y num2 almacenarn nmeros y a num1 se la asign el valor de 10 inmediatamente. DECLARAR como NUMERO num1 = 10 , num2 let1 y let2 almacenarn letras y se inicializan en A y b respectivamente. DECLARAR como LETRA let1 = A , let2 = b Nota: A muchos programadores no les parece importante colocar la declaracin de las variables en su pseudocodigo, ya que la forma de declararlas es muy diferente entre los muchos lenguajes de programacin que hay, pero personalmente lo hago para dar claridad a los programas y asegurar la consistencia de los datos que se almacenan en las variables. Importante: Cuando se hace uso de una variable, se debe ver si se le ha asignado un valor antes de usarla, ya que de lo contrario contiene lo que se denomina BASURA. (Por eso es muy recomendable inicializarlas con algn valor en el momento de la declaracin). La basura simplemente aparece cuando a una variable se le asigna espacio en la memoria. Dicho espacio no est en blanco ya que como los datos internamente en el computador se manejan en forma binaria hay una cantidad determinada de unos y ceros en ese espacio (Estados aleatorios que se crean cada vez que se enciende el computador). Si no se asigna a dicha variable un valor y simplemente se utiliza en una operacin aritmtica, el valor de la variable depender de los unos y ceros que haba cuando se le asign el espacio, es decir, no se sabr con seguridad cual es el valor de esa variable en ese momento, por lo que podra producir graves errores en las siguientes instrucciones del algoritmo.

Ejemplo: DECLARAR como NUMERO num1 , num2 , suma // num1 , num2 y suma son nmeros. num1 = 10 // a num1 se le asigna el valor de 10 suma = num1 + num2 // a suma se le asigna el valor de num1 (10) y de num2 ( ? ) , por lo que no se // sabra cual es el valor actual de suma. Cuando se trata de asignar a una variable de tipo NUMERO un valor de LETRA y viceversa, se genera un error de incompatibilidad de tipos, ya que la nica forma de realizar una operacin de asignacin entre variables es que las variables sean del mismo tipo. Pero en ocasiones especiales, el programador desea convertir un numero en una letra o al revs, por lo que se utiliza un mtodo llamado CASTING. El Casting consiste en transformar el valor de una variable de un tipo especifico a otro tipo determinado. Ejemplo: DECLARAR como NUMERO num DECLARAR como LETRA let num = 65 let = LETRA ( num ) // a let se le asigna un 65, pero como es LETRA, se interpretara como el carcter // cuyo cdigo ASCII sea 65, o sea la letra A. let = B num = NUMERO ( let ) // a num se le asigna el cdigo ASCII de la letra B, o sea 66. Las variables tienen una gran diferencia con las CONSTANTES, que se rigen por las mismas normas de las variables excepto que inmediatamente son declaradas se les debe asignar un valor, que en ningn momento puede ser cambiado dentro del algoritmo. Para declarar Constantes se utilizar la palabra clave CONSTANTE entre la palabra DECLARAR y el tipo de la variable. Un numero cualquiera, puede ser catalogado como una constante ya que su valor es inmutable. Ejemplo: el numero 1 siempre va a valer 1 y nada ms. Ejemplo: DECLARAR como CONSTANTE pi = 8 pi = 3.1416 // Obsrvese que inmediatamente se le // asign un valor que no podr ser cambiado // generara un error ya que pi fue declarada como CONSTANTE. NUMERO

1.2. Los operadores Los operadores son los que permiten efectuar las operaciones aritmticas en el algoritmo. Los que se van a usar en este pseudocodigo son los siguientes:

+ , - , * , / : Suma, resta, multiplicacin y divisin respectivamente. Son las mismas operaciones que en el clculo normal con una pequea diferencia: El resultado de estas operaciones puede ser un numero entero o un fraccionario, por lo que se deber especificar cual es el resultado que se desea. Para esto se utilizar la palabra clave FRACCION Y ENTERO.
Si no se coloca ninguna palabra clave en alguna operacin aritmtica, se tomar que la operacin es de tipo FRACCION. (Tipo por defecto).

Ejemplo: DECLARAR como NUMERO a , b , res a = 10 b = 15 res = FRACCION (b / a) // En res se almacena el nmero 1.5 res = ENTERO (b / a) // En res se almacena el nmero 1. (Se elimina la parte fraccionaria). res = b / a // En res se almacena un 1.5. (Las operaciones son FRACCION por defecto). Las palabras clave FRACCION y ENTERO son usadas para cualquier operacin aritmtica. ^ : Potenciacin: Eleva un numero a una potencia determinada. Ejemplo: DECLARAR como NUMERO a , b , res a = 10 b = 2 res = a ^ b // En res se almacena el nmero 100 RAIZ : Representar la raz n-sima de un nmero. Se usa asi: RAIZ ( n , numero ) , donde n es el radical y numero es el numero al cual se le va a calcular la raiz. DECLARAR como NUMERO a , b , res a = 3 b = 9 res = RAIZ ( a , b ) // En res se almacena el nmero 3 mod: Modulo: Devuelve como resultado, el residuo de la divisin ENTERA entre dos nmeros. Algoritmicamente el modulo se puede definir as: A mod B = A ENTERO(A / B)*B Ejemplo: DECLARAR como NUMERO a , b , res a = 10 b = 2 res = a mod b // En res se almacena nmero 0 ya que el residuo de dividir 10 entre 2 es 0. res = a mod 3 // En res se almacena un 1 ya que el residuo de 10/3 es 1. IMPORATANTISIMO: Las operaciones en un computador tienen un cierto orden de importancia, es decir, algunas se efectan primero que otras. Este orden en forma descendente es: Potenciacin, modulo, divisin, multiplicacin, suma y resta. Si no se coloca ningn parntesis en la operacin aritmtica, el orden anterior es el que tiene la mquina para realizar las operaciones, pero al colocar algo entre parntesis, esa parte de operacin primar sobre las dems.

Ejemplo: DECLARAR como NUMERO num num = 3 + 10 / 2 // la divisin prima sobre la suma por lo que primero se resuelve 10 / 2 (5) y luego se // suma el 3 por lo que en num se almacenara un 8. num = (3 + 10) / 2 // El parntesis hace que la operacin interna prime sobre las dems, por lo que el // resultado sera 13 / 2 , o sea 6.5. num = ENTERO ((3 + 10) / 2) * 4.3 // La 1 parte es igual a la anterior, pero el resultado es entero, o // sea 6 y luego se multiplica por 4.3 = 25.8 (el resultado final es FRACCION) num = 25 / 5 * 2 // la divisin prima sobre la multiplicacin por lo que el resultado sera 5 * 2 = 10. num = 25 / (5 * 2) // se resuelve primero el parntesis, o sea 25 / 10 = 2.5 num = 10 mod 4 / 2 // se resuelve primero el modulo, o sea num = 2 / 2 = 1 num = 10 mod (4 / 2) // se resuelve primero el parntesis, o sea num = 10 mod 2 = 0 num = 10 ^ 2 mod 2 // la potenciacin prima, o sea num = 100 mod 2 = 0 num = 10 ^ (2 mod 2) // el parntesis hace que el modulo prime, o sea num = 10 ^ 0 = 1 Nota: Obsrvese que segn se coloquen o no parntesis en las distintas operaciones aritmticas los resultados cambian, por lo que en el momento de escribir una operacin en un algoritmo, se debe tener muy en cuenta la primaca de los operadores. Operadores lgicos: ( >,<,<=,>=,=,!=,<>,AND,OR,NOT): Sirven para hacer preguntas lgicas, como si una variable es mayor que otra, igual,menor o igual, diferente, etc. Retornan lo que se conoce como un valor de verdad, (TRUE o FALSE),(VERDADERO o FALSO). Estos dos valores, se tomarn asi, de ahora en adelante: 1 = TRUE 0 = FALSE. El operador diferente de, se podr especificar con != o con < > , segn el programador lo elija. Los operadores AND,OR,NOT se usan para ligar operadores logicos. AND indica que las dos condiciones deben ser verdaderas para que el resultado sea verdadero, OR indica que solo una de las dos condiciones debe ser verdadera para que la respuesta sea verdadera y NOT indica que la condicion debe ser falsa para que la respuesta sea verdadera. Aqu se puede visualizar ms facil el uso de estos operadores: Ejemplo: DECLARAR como NUMERO num1 = 10 , num2 = 20 , num3 = 10 , res res = num1 > num2 // a res se le asigna el valor de FALSE, o sea 0. res = num1 <= num2 AND num1 = num3 // ambas condiciones son TRUE, o sea res=1. res = NOT num1 = 10 // como num1 si es igual a 10, la condicin NOT num1=10 es falsa, o sea 0. res = num1 = 10 OR num2 = 10 // como una condicin es TRUE, res = TRUE =1. Estos operadores, sern muy tiles cuando se vean estructuras lgicas como ciclos, condiciones, etc. (UNIDAD 2). Por ltimo como se ha observado, en todos los ejemplos, las explicaciones han ido despus de un signo //. Este signo indica comentario, o sea que al colocarlo en alguna parte del algoritmo, se podr escribir cualquier cosa en la misma lnea y no ser tomado en cuenta como una instruccin del algoritmo. Los comentarios sirven mucho para colocar explicaciones cortas de lo que se est haciendo en el algoritmo, adems se puede usar para colocar seas en algunas instrucciones que se quieren tener en cuenta. Estos comentarios es mejor colocarlos un poco alejados del cdigo del algoritmo, para evitar errores de lectura del algoritmo ms adelante o por otros programadores. 1.3. Caractersticas de un Algoritmo Hasta el momento, no se ha escrito ningn algoritmo en este texto; lo que se ha hecho es escribir segmentos de posibles algoritmos para dar algunos ejemplos.

Un verdadero algoritmo debe tener las siguientes caractersticas: 1. 2. Debe tener un numero finito de instrucciones, o sea un principio y un final, por lo que se deben sealar dentro del algoritmo donde comienza y donde termina. Para esto se utilizaran las palabras claves INICIO ( PRINCIPAL ) y FIN ( PRINCIPAL ). Puede tener o no datos de entrada, es decir, datos iniciales que se necesitan conocer para que el modelo que el algoritmo representa funcione. Por lo tanto se necesita un mecanismo para leer esos datos desde los dispositivos de entrada del computador. Para esto utilizaremos el mtodo READ ( parametro1 , parametro2).Donde el parametro1 ser un mensaje (entre (comillas dobles)) que le indicar al usuario cual es el dato que debe digitar y el parametro2 ser la variable que almacenar el dato que el usuario digite. Ejemplo: INICIO ( PRINCIPAL ) DECLARAR como NUMERO radio , area DECLARAR como CONSTANTE NUMERO pi = 3.1416 READ ( Por favor, digite el radio del circulo : , radio ) area = pi * radio ^ 2 // formula para calcular el rea de un circulo FIN ( PRINCIPAL ) En este ejemplo, en la pantalla del computador saldra: Por favor, digite el radio del circulo: En la pantalla, el usuario podr escribir el dato que significara el radio de un circulo y se almacenara en la variable radio.

Este ejemplo todava no se puede catalogar como un algoritmo, ya que todava le falta cumplir con otra caracterstica de los algoritmos. 3. Debe tener al menos uno o ms datos de salida, que en forma practica sera el resultado al modelo que fue diseado por el programador y que por obvias razones deben ser mostrados mediante algn dispositivo de salida del computador. Para esto se utilizar el mtodo WRITE ( parametro1 , parametro2 ). Donde el parametro1 es un mensaje (igual que en el mtodo READ), que le indicar al usuario que significado tiene el dato que se est mostrando en pantalla y el parametro2 es la variable que contiene el resultado final del algoritmo. Retomando el ejemplo anterior, el algoritmo finalmente quedara: INICIO ( PRINCIPAL ) DECLARAR como NUMERO radio , area DECLARAR como CONSTANTE NUMERO pi = 3.1416 READ ( Por favor, digite el radio del circulo : , radio ) area = pi * radio ^ 2 // formula para calcular el rea de un circulo WRITE ( El rea de el circulo es: , area ) FIN ( PRINCIPAL ) En el ejemplo anterior, en la pantalla del computador saldra: Por favor, digite el radio del circulo: 5 El radio del circulo es: 78.53 En la pantalla, si por ejemplo, el usuario digit un 5 como el radio del circulo. El mensaje de respuesta aparecera as:

Nota: Si son varios los datos de entrada, lo que se hace es simplemente repetir la orden READ con las variables y los mensajes que se requieran, pero si son varios los datos de salida, se pueden colocar los mensajes y/o las variables separadas por coma.

Ejemplo: WRITE ( La coordenada es: , x , , , y ) La anterior instruccin mostrara en la pantalla despus de la coordenada es, el valor de la variable x, luego mostrara una coma y por ultimo el valor de la variable y. Si ms adelante, en el algoritmo hay otra instruccin WRITE, se escribir en el mismo rengln en la pantalla, pero si quisiramos que la prxima instruccin WRITE se escriba un rengln ms abajo, podemos agregar la palabra FINLINEA (Fin de Lnea). Ejemplo: WRITE ( La coordenada es: , x , , , y , FINLINEA) De esta manera estamos indicando que la prxima instruccin WRITE se escribir un rengln ms abajo del que se escribi este mensaje. En algunas ocasiones, el resultado de un algoritmo no se representa en el valor de una variable, sino en una frase que le indique al usuario cual fue dicho resultado, por lo que se puede omitir el segundo parmetro en el mtodo WRITE. Tambin en caso de que no se desee mostrar ningn mensaje al usuario acompaando al valor de la variable, se puede omitir el primer parmetro tanto en el mtodo READ, como en el mtodo WRITE. Ya hemos visto las partes bsicas de un algoritmo, ahora pasaremos a disear algoritmos con instrucciones especiales (ciclos, decisiones, etc.), desde los ms simples hasta los ms complejos. 1.4. PASOS PARA DISEAR UN ALGORITMO. Aunque no hay un mtodo general para disear algoritmos, si se puede decir que lo ms adecuado es seguir con los siguientes pasos al tratar de resolver un problema determinado: 1. EL ANLISIS: Es importantisimo hacer un buen anlisis de cual es especficamente el problema a resolver. Para esto es bueno ayudarse mediante grficos del problema o en caso de que no sea graficable, tambin se puede resolver el problema para casos especficos y luego generalizarlo para todos los posibles casos. Tambin se deben observar cuales seran los casos especiales, es decir, aquellos casos que no cumplan la norma general, y tratar de evaluarlos de otra forma. Este paso es el que ms tiempo debe llevarle a un buen programador, ya que de un buen anlisis depende los buenos resultados que arroje el algoritmo. 2. ESCRIBIR EL ALGORITMO: Despus de haber analizado el problema en una forma abstracta, se debe llevar al papel, mediante instrucciones adecuadas al anlisis. Si el problema fue bien analizado, este paso es muy rpido a comparacin del anterior. 3. PRUEBA DE ESCRITORIO: Este paso es opcional y se aplica siguiendo paso por paso las instrucciones del algoritmo, anotando los diferentes valores que van tomando las variables, de forma que se pueda verificar si hay errores en alguna instruccin. Obviamente, ste mtodo es muy engorroso para algoritmos muy extensos, por lo que en estos casos no sera aplicable. UNIDAD 2: DISEO DE ALGORITMOS CON VARIABLES SIMPLES Las variables simples son las que ya hemos visto (NUMERO y LETRA), ya que solo almacenan un dato a la vez.

Los algoritmos, adems de tener las instrucciones bsicas que ya hemos visto (INICIO, FIN, READ, WRITE), tambin tienen unas instrucciones lgicas que ayudan al programador a que el algoritmo sea lo ms parecido posible a su modelo. Estas instrucciones son: 2.1. ESTRUCTURA CONDICIONAL ( IF ... THEN ... ELSE ... END IF ) La estructura condicional es simplemente una instruccin que evala una expresin lgica, que solo en el caso de resultar verdadera permite ejecutar una serie de instrucciones. La palabra else coloca cuando se desea que otro grupo de instrucciones se ejecuten en caso de que la expresin lgica sea falsa. En palabras sencillas, esta estructura quiere decir: SI expresin lgica , ENTONCES < instrucciones > DE LO CONTRARIO < instrucciones > FIN SI. Ejemplo: Realizar un algoritmo que reciba la edad de una persona y diga cual es su estado actual segn la clasificacin: menor de 10 aos (Nio), entre 10 y 18 aos (Adolescente), entre 18 y 40 aos (Adulto), mayor que 40 aos(Anciano). INICIO ( PRINCIPAL ) DECLARAR como NUMERO edad READ ( Por favor, escriba su edad , edad ) IF edad < 10 THEN // IF #1 WRITE ( ES USTED UN NIO ) ELSE IF edad < 18 THEN // IF #2 WRITE ( ES USTED UN ADOLESCENTE ) ELSE IF edad < 40 THEN // IF #3 WRITE ( ES USTED UN ADULTO ) ELSE WRITE ( ES USTED UN ANCIANO ) END IF // IF #3 END IF // IF #2 END IF // IF #1 FIN ( PRINCIPAL ) En este ejemplo, la primera condicin pregunta si la edad es menor de 10 aos, en caso afirmativo escribe en pantalla que el usuario es un nio, pero en caso de que no (ELSE), significa que tiene diez aos o ms por lo que se pregunta si es menor de 18 aos. As se hace sucesivamente hasta que se llegue al caso de que el usuario escribi un nmero mayor que 40 por lo que la ejecucin entra al ultimo ELSE, o sea que tiene 40 aos o ms por lo que no hay necesidad de volver a preguntar si edad >= 40 ya que es lgico. Observes tambin que en este algoritmo los comentarios son de mucha ayuda ya que ayudan a comprobar que cada instruccin IF tiene su respectivo END IF , para evitar graves errores lgicos. Adems la forma de escribir las instrucciones que estn dentro del IF estn escritas con una sangra denotando as que estn dentro de la instruccin para poderlas diferenciar de las dems instrucciones.

2.2. INSTRUCCIN DE SALTO DE EJECUCIN ( GOTO ) La instruccin GOTO o ir a, sirve para hacer que en un momento determinado, la ejecucin del algoritmo no contine en la siguiente instruccin sino en otra instruccin diferente que debi haber sido etiquetada con un nombre determinado con anterioridad.

La etiqueta de una instruccin se rige por las mismas reglas para nombrar variables (Unidad 1), y se coloca antes de comenzar la instruccin a la que se desea saltar desde el GOTO. Ejemplo: Hacer un algoritmo que reciba la edad y el peso de una persona y que le diga si est o no pasado de peso si se supone que una persona est pasada de peso cuando ste triplica su edad. Adems debe verificarse que el usuario no digite la edad o el peso menores o iguales que cero, caso en el que deber aparecer un mensaje de error. INICIO ( PRINCIPAL ) DECLARAR como NUMERO edad , peso READ (Digite su edad , edad ) IF edad > 0 THEN READ (Digite su peso , peso ) IF peso > 0 THEN IF peso >= 3*edad THEN // si el peso triplica la edad... WRITE (Usted est pasado de peso !!!) ELSE WRITE (Su peso es adecuado) END IF ELSE GOTO ERROR // si el peso es menor o igual que cero se salta a la etiqueta ERROR END IF ELSE GOTO ERROR // si la edad es menor o igual que cero se salta a la etiqueta ERROR END IF EXIT PRINCIPAL // Si la edad y el peso eran correctos no se deben ejecutar las instrucciones de la // etiqueta ERROR, as que se termina la ejecucin del algoritmo.(VER INSTRUCCIN EXIT) ERROR : WRITE (Los datos no deben ser menores que cero !!!) // Mensaje de error ya que uno de los //datos es errneo FIN ( PRINCIPAL ) 2.3. INSTRUCCIN DE SALIDA DE UN ALGORITMO ( EXIT ) La instruccin EXIT simplemente sirve para cuando se desea terminar la ejecucin de un algoritmo en un momento determinado sin terminar con el resto de instrucciones que estn por debajo de EXIT. Es muy til cuando se detectan errores con los datos en un algoritmo (Si hay un error grave, simplemente se saca por pantalla un mensaje de error y se termina la ejecucin). Para ver un ejemplo, se puede ver el ejemplo anterior de la instruccin GOTO, donde se usa para evitar que se ejecute una instruccin de error en caso de que todo haya salido bien con el algoritmo. 2.4. CICLO O BUCLE MIENTRAS ( WHILE ... DO ... END WHILE ) El ciclo MIENTRAS, no es mas que una instruccin IF etiquetada con un cierto nombre con una instruccin GOTO al final apuntando a la etiqueta de la instruccin IF de modo que la pregunta se hara hasta que el resultado de la expresin lgica sea FALSO.

Ejemplo: DECLARAR como NUMERO cont = 0 CICLO : // Etiqueta de nombre CICLO IF cont < 10 THEN // condicin cont = cont + 1 // se incrementa la variable cont de modo que en algn momento // sea mayor que 10 GOTO CICLO // El GOTO hace que la ejecucin regrese hasta el IF. END IF // Cuando la expresin del IF sea falsa, la ejecucin llega aqu, por lo que se // salta la instruccin GOTO y finalmente termina el ciclo de instrucciones El anterior segmento de Algoritmo es igual al siguiente:

DECLARAR como NUMERO cont = 0 WHILE cont < 10 DO // se evala si cont es menor que 10 cont = cont + 1 // si cont si era menor que 10 se aumenta en uno END WHILE // se regresa al principio del WHILE a evaluar nuevamente la // expresin de modo que si es FALSA termina el ciclo y se contina la ejecucin // del algoritmo despus del END WHILE. Obviamente, copiar estas instrucciones cada vez que se necesite hacer un ciclo es muy engorroso, por lo que se cre la instruccin WHILE... DO... END WHILE Por lo tanto hay que asegurarse que en algn momento, la condicin se haga falsa ya que de lo contrario, las instrucciones se repetiran indefinidamente dando lugar a lo que se conoce con el nombre de LUP O CICLO INFINITO. Si un proyecto de algoritmo cayera en este error, ya no se catalogara ni siquiera algoritmo ya que rompera con una caracterstica fundamental de los algoritmos que es el hecho de tener un FIN. En palabras sencillas, el ciclo mientras se interpreta: MIENTRAS condicin lgica HAGA < instrucciones > FIN MIENTRAS. Ejemplo: Elaborar un algoritmo que reciba un nmero (ENTERO NATURAL) mayor que cero y que d como respuesta el mismo nmero, pero con las cifras al revs. Anlisis: Un nmero entero en base 10 (decimal), est compuesto por unidades, decenas, centenas, etc. Si por ejemplo se quisiera averiguar cuantas unidades posee un cierto nmero, simplemente se divide el nmero por 10 (DIVISIN ENTERA) y el residuo sera las unidades que tiene el nmero. (En realidad se est hallando la ultima cifra del numero). Para hallar la penltima cifra del numero, simplemente sera repetir el procedimiento anterior, pero quitndole la ultima cifra, lo que se logra simplemente asignndole al numero, su anterior valor dividido por 10 (DIVISION ENTERA). As se hace sucesivamente, hasta cuando el numero al ser dividido por 10 se haga cero (Lo que indicara que no tiene ms cifras), por lo tanto, la condicin del ciclo sera WHILE numero > 0. Por ejemplo, si el nmero fuera: 234, el procedimiento sera: num = 234 num mod 10 , se mostrara la ltima cifra del numero ( 4 ) num = ENTERO(num / 10),dara como resultado num = 23, o sea el antiguo nmero sin la ltima cifra num mod 10, se mostrara un 3 num = ENTERO(num / 10),dara como resultado num = 2, o sea el antiguo nmero sin la ltima cifra

num mod 10, se mostrara un 2 num = ENTERO(num / 10),dara como resultado num = 0, lo que indica que se acabaron las cifras del numero, por lo que se termina el procedimiento. Obsrvese que las cifras del nmero se muestran desde la ultima hasta la primera. El algoritmo, finalmente quedara: INICIO ( PRINCIPAL ) DECLARAR como NUMERO num , aux READ (Digite el nmero, num ) aux = num // Se guarda el valor de num en otra variable, para no daar su valor en el ciclo WHILE aux > 0 DO WRITE ( aux mod 10 ) // se muestra la ultima cifra del numero aux = ENTERO ( aux / 10 ) // al numero se le quita la ultima cifra END WHILE FIN ( PRINCIPAL ) 2.4. BUCLE ( DO ... WHILE ... ) Esta instruccin tiene exactamente la misma utilidad del ciclo WHILE, solamente que en el ciclo WHILE se pregunta si la expresin lgica es verdadera desde la primera vez para poder ejecutar las instrucciones que estn antes del END WHILE, pero en este bucle DO, las instrucciones que estn en el ciclo se ejecutarn sin problema la primera vez, y solo entonces es que se comienza a preguntar si la expresin del WHILE es verdadera. En caso afirmativo, la ejecucin regresa hasta la palabra DO y vuelve a ejecutar las instrucciones. Las instrucciones entre DO y WHILE se repiten hasta que la expresin lgica sea FALSA. 2.5. BUCLE ( DO... UNTIL... ) Es exactamente igual que la anterior instruccin, excepto que las instrucciones que estn entre las palabras DO y UNTIL (HASTA QUE) se ejecutan hasta que la expresin lgica que se coloca despus de UNTIL sea verdadera, es decir, dicha condicin marcar el fin del ciclo, lo que significa que las instrucciones se repiten mientras la expresin sea FALSA. 2.6. CICLO O BUCLE PARA ( FOR ... TO ... STEP ... END FOR) Por lo que se ha podido observar con los ciclos anteriores, la ejecucin repetitiva de las instrucciones se rige por una expresin lgica, por lo que son usados cuando el programador no sabe con exactitud cuantas veces se repetir el ciclo. Pero en algunas ocasiones, el programador sabe cuantas veces el ciclo debe ser ejecutado, por lo que se dise el ciclo FOR. El uso del ciclo FOR es el siguiente: Despus de la palabra FOR, se inicializa una variable en un valor determinado, que ser la parte inicial del ciclo; luego, se coloca la palabra TO seguida de un numero que indicar cual ser el limite para esa variable (o sea que cuando la variable se salga de dicho limite, el ciclo terminar); la palabra STEP sirve para especificar el valor que aumentar (o disminuir) la variable cada vez que se repita el ciclo. Si la palabra STEP no se coloca se acepta por defecto que el valor de aumento es 1, o sea que la variable aumentar de uno en uno cada vez que el ciclo se repita. El ciclo FOR se puede interpretar como un WHILE, donde simplemente la variable de la condicin lgica fue inicializada con anterioridad en un valor inicial y la condicin es hasta que la variable sea menor o igual que un valor final, es decir: FOR i = 0 TO 10 STEP 2 suma = suma + i END FOR ES IGUAL A: i=0 WHILE i <= 10 DO suma = suma + i i=i+2 END WHILE

Obviamente, si el incremento del ciclo FOR fuera negativo, la forma de representarlo en forma de ciclo WHILE cambiara, ya que la condicin no sera menor o igual sino mayor o igual: FOR i = 10 TO 0 STEP -2 suma = suma + i END FOR i = 10 WHILE i >= 0 DO suma = suma + i i=i-2 END WHILE

ES IGUAL A:

Por lo que se ha dicho, el ciclo FOR se repite desde una posicin inicial hasta que la variable sobrepase un valor final, por lo que se puede decir que EL NUMERO DE VECES QUE SE REPITE UN CICLO FOR ES FINAL INICIO + 1. Ejemplo : Hacer un algoritmo que calcule la multiplicacin de dos nmeros, pero solo usando el operador de Suma ( + ). Anlisis: Una multiplicacin de dos nmeros A y B, no es ms que una suma del nmero A cuantas veces diga el nmero B. Por ejemplo: 2 * 3 = 2 + 2 + 2 (se suma el nmero 2, un total de 3 veces). 3 * 5 = 3 + 3 + 3 + 3 + 3 (se suma el nmero 3, un total de 5 veces). Como se puede ver, en este ejemplo, se sabe cuantas veces se debe ejecutar el ciclo (un total de B veces, donde B es uno de los mltiplos), por lo que se recomienda utilizar el ciclo FOR. El algoritmo quedara as: INICIAR ( PRINCIPAL ) DECLARAR como NUMERO num1 , num2 , result , i READ(Primer multiplo:, num1) READ(Segundo multiplo:, num2) result = 0 // se inicia el resultado en 0, ya que en caso de que num2 fuera 0, no se entrara ni // la primera vez al ciclo (porque el cero esta fuera del rango [ 1 ,num2 ]), y result // contendra BASURA, cuando el resultado real de multiplicar por 0 es 0. FOR i = 1 TO num2 // el ciclo se repetir para i = 1,2,...num2 , o sea num2 veces. En caso de // que num2 sea 0, simplemente result queda valiendo 0 y no entra al ciclo. result = result + num1 // se suma al resultado el primer mltiplo de forma que se acumule END FOR WRITE (El resultado de la multiplicacin es:, result ) FIN ( PRINCIPAL ) Obsrvese que el ciclo FOR aumenta automticamente la variable segn lo especificado en la palabra STEP (En el ejemplo anterior, como no se especific, el valor es 1), por lo que no hay que aumentarla dentro de las instrucciones del ciclo; lo que lo diferencia del ciclo MIENTRAS donde hay que escribir el aumento de la (s) variables para que la expresin lgica llegue a ser FALSA en algn momento. 2.7. CONTADORES Y ACUMULADORES Aunque sin haberlos explicado an, en los algoritmos que se han diseado anteriormente se han usado unas variables que tienen un deber muy especifico dentro de los programas : CONTAR y ACUMULAR.

Los CONTADORES son aquellas variables que se van incrementado un valor especifico cada vez que se ejecutan las instrucciones de un ciclo cualquiera. Esto puede servirnos ya sea para hacer que el ciclo termine cuando el contador haya llegado hasta un valor limite o simplemente para conocer cuantas veces se ejecuto una o varias instrucciones. Ejemplo: Haga un algoritmo que muestre en la pantalla todos los nmeros primos menores que 100 y que diga cuantos fueron los nmeros primos encontrados. Sugerencia : Utilizar el operador mod. Anlisis: Los nmeros que van a ser analizados para decir si son primos o no, son los nmeros del 1 al 100, por lo que una variable ser la encargada de contar los nmeros del 1 al 100. (Ser un contador). Un nmero puede ser divisible por 1, 2, 3, 5, y/o por si mismos. Un nmero primo es aquel nmero natural que solo es divisible por 1 y por si mismo, o sea que no es divisible por 2, 3, y 5. Las nicas excepciones a la regla anterior seran los mismos nmeros 2, 3, 5 que obviamente son divisibles por 2, 3 5, pero que son ellos mismos, por lo que se deben mostrar dentro de los nmeros primos; entonces, lo que haremos, ser mostrar el 1,2,3 y 5 primero y despus evaluar todos los nmeros desde el 6 hasta el 100 para comprobar si son primos o no (Evaluando si no son divisibles por 2,3 5). Se debe tener en cuenta, que para saber si un nmero es divisible por otro, el residuo al dividir los dos es cero, por lo que inversamente, si un nmero no es divisible por otro, su residuo es diferente de cero. No olvidar que el residuo se obtiene mediante el operador mod . Por ultimo se utilizar otra variable CONTADOR, para que cuente el nmero de veces que se mostrar un nmero primo, por lo que obviamente debe ser inicializada en cero. INICIAR ( PRINCIPAL ) DECLARAR como NUMERO i ,veces = 4 //comienza en 4, para tener en cuenta los casos especiales WRITE (Los nmeros primos son: 1, 2 , 3 , 5 ) // se muestran primero los casos especiales 1,2,3,5 FOR i = 6 TO 100 // el ciclo se repetir hasta que i llegue a 100. IF i mod 2 <> 0 AND i mod 3 <> 0 AND i mod 5 <> 0 THEN WRITE ( , , i ) // si es primo, se muestra el nmero (la coma es por esttica) veces = veces + 1 // se incrementa el contador de nmeros primos END IF END FOR WRITE (El total de nmeros primos es: , veces) FIN ( PRINCIPAL ) El anterior algoritmo, mostrara los nmeros primos del 1 al 100, separados por comas, o sea: 1, 2, 3, 5, 7, 11, etc. Los ACUMULADORES son variables que, como su nombre lo indica se usan para ir acumulando los resultados de algunas operaciones dentro de ciclos, de modo que dichos resultados sern usados como trminos en las siguientes operaciones. Un ejemplo claro del uso de ACUMULADORES es el ejemplo que calcula la multiplicacin de dos nmeros, pero solo con sumas (antes del anterior), donde se puede ver que el resultado de las sumas anteriores se va acumulando en la variable result, que cuando se repita el ciclo ser uno de los sumandos de la operacin, por lo que el resultado total ser la suma de todas las operaciones anteriores + la suma actual. 2.8. CICLOS ANIDADOS En un algoritmo, usar ciclos anidados es usar uno o varios ciclos dentro de otro, podrn ser WHILE, UNTIL o FOR.

Obviamente, el ciclo ms externo tendr que esperar a que el interno se repita todas las veces necesarias, para que l simplemente avance una vez, o sea que en palabras sencillas se podra decir que entre ms externo sea el ciclo, ms lentas sern sus instrucciones. Ejemplo: Disear un algoritmo que calcule un nmero, elevado a una potencia cualquiera, pero solo utilizando el operador de suma (+). Anlisis: Se sabe que un numero elevado a la n, es simplemente multiplicar el nmero por si mismo, n veces, lo que implicara un ciclo de multiplicaciones, pero como se vio en el ejemplo anterior una multiplicacin de dos nmeros es un ciclo de sumas, o sea, que para hacer este algoritmo, se necesitarn dos ciclos, uno que indicar el nmero de multiplicaciones sucesivas (el ms externo), y uno que resolver cada multiplicacin en forma de sumas (el ms interno). Tambin, se sabe que todo nmero elevado al exponente 0, da como resultado 1, por lo que la variable que almacenar el resultado se debe inicializar en uno y hacer que si el exponente vale 0, la ejecucin no entre ninguna vez al ciclo de multiplicaciones. Adems se debe tener en cuenta, el hecho de que el resultado de las multiplicaciones se debe ir almacenando en una variable que a su vez ser uno de los mltiplos de la siguiente multiplicacin (el otro mltiplo ser la base), por ejemplo, si la base fuera 3 y el exponente 4, sera: 3 ^ 4 = 1 * 3 * 3 * 3 *3 el uno es el estado inicial de la variable del resultado.

la primera multiplicacin sera 1 * 3, o sea : 1 + 1 + 1 = 3 (Obviamente, el uno no afecta el resultado) la segunda multiplicacin sera 3*3, o sea : 3 + 3 + 3 = 9 la tercera multiplicacin sera el resultado de la multiplicacin anterior por la base ( 3 ), o sea: 9 * 3, que es: 9 + 9 + 9 = 27 la cuarta sera 27 * 3 = 27 + 27 + 27 = 81, que es el resultado de 3 ^ 4. Obsrvese adems que el numero de veces que se efectu la multiplicacin fueron 4, o sea el nmero del exponente. INICIAR ( PRINCIPAL ) DECLARAR como NUMERO base , exp , mult , res , i , j READ(Digite la base del nmero , base) READ(Digite el exponente del nmero , exp) res = 1 // se inicializa en uno al resultado por si el exponente es 0. FOR i = 1 TO exp // el ciclo se repetir exp 1 + 1 veces = exp veces. mult = 0 FOR j = 1 TO base // se efecta base * res, pero solo con sumas. mult = mult + res END FOR res = mult // se acumula el resultado, para que sirva como nuevo mltiplo para la prxima vez // que se efecte la multiplicacin END FOR WRITE (El resultado es: , res ) FIN ( PRINCIPAL )

EJERCICIOS DE LA UNIDAD 3 Las respuestas estn al final de los ejercicios, pero se recomienda tratar de que usted mismo llegue a las respuestas y solo mirarlas para comparar los resultados y verificar los errores.

1. Disee un algoritmo que permita conocer el factorial de un nmero cualquiera. 2. Elabore un algoritmo que calcule la el resultado de la siguiente sucesin: f (x) = x ^ 0 / 1! + x ^ 1 / 3! + x ^ 2 / 5! + .... Donde son conocidos (obviamente dados por el usuario), el valor de x y el nmero de trminos que tendr la sucesin ( exactitud ) . 3. Haga un algoritmo, que permita conocer 20 puntos diferentes en el plano cartesiano de una recta que pasa por dos puntos. 4. Elabore un algoritmo que permita conocer 20 puntos diferentes de cada lado de un tringulo equiltero, el cual tiene uno de sus vrtices en el punto 0,0 del plano cartesiano y uno de sus lados sobre el eje x. RESPUESTAS: 1.Anlisis: El factorial de un nmero es simplemente, el resultado que da al multiplicar todos los nmeros naturales, menores o iguales a l sin contar el cero, por ejemplo 5! = 1 * 2 * 3 * 4 * 5 = 100. Por lo anterior, simplemente haremos un ciclo que comience en 1 y termine en el nmero que digite el usuario (avanzando de 1 en 1) y que se vaya acumulando el resultado de las multiplicaciones. El caso especial en esta algoritmo sera especificar que el factorial de 0 , est definido como uno, por lo que habr que tenerlo en cuanta en el diseo. INICIAR ( PRINCIPAL ) DECLARAR como NUMERO num , i , res READ(Digite el nmero , num) res = 1 // se inicializa en uno al resultado por si el nmero es 0. FOR i = 1 TO num // el ciclo se repetir hasta que i llegue al nmero. res = res * i // en res se va acumulando el resultado de las multiplicaciones y luego se // multiplica por i (que avanza de uno en uno) END FOR WRITE (El factorial es: , res ) FIN ( PRINCIPAL ) 2.Anlisis: Habr un ciclo principal que ser el encargado de controlar el nmero de trminos de la sucesin e ir acumulando el resultado de las sumas y dentro de l se efectuarn las operaciones de potenciacin y factorial. Obsrvese que el nmero que se le aplica el factorial comienza en 1 y va aumentando de 2 en 2 por cada trmino ( cada vez que se repite el ciclo principal ), por lo que se puede decir en general que dicho nmero, representado en forma del trmino, sera: numero = 2 * i + 1 i = 0,1,2,3,etc.

Donde i sera el trmino. Obsrvese que cuando i = 0 (primer trmino), el numero del factorial ser 2 * 0 + 1 = 1, cuando i = 1, ser 2 * 1 + 1 = 3 y asi sucesivamente ir incrementndose de 2 en 2, hasta llegar al nmero de trminos deseado.

Tambin se observa que el exponente de la potenciacin del numerador de cada trmino va aumentando de 1 en 1, comenzando desde 0. INICIAR ( PRINCIPAL ) DECLARAR como NUMERO ter , i , j , x , res , fact READ(Digite el nmero de trminos , ter ) READ(Digite el valor de x , x ) res = 0 // se inicializa en cero ya que va a acumular el resultado total de las sumas. FOR i = 0 TO ter - 1 // el ciclo se repetir ter 1 0 + 1 veces = ter veces. fact = 1 FOR j = 1 TO 2 * i + 1 // se calcula el factorial de 2 * i + 1 ( 1! , 3! , 5! , etc. ) fact = fact * j END FOR res = res + ( x ^ i ) / fact // se acumula en el resultado, el trmino i. (El exponente del // numerador sera 0,1,2,3,etc.) END FOR WRITE (El resultado de la sucesin es: , res ) FIN ( PRINCIPAL ) 3.Anlisis: Para conocer 20 puntos de una recta, es necesario conocer su ecuacin. Para conocer la ecuacin de una recta es necesario conocer dos puntos de la recta o un punto y su pendiente. En este caso, el usuario digitar dos puntos ( x , y ) , ( x , y ) , para poder identificar la ecuacin de la recta. Para esto, se sabe que la ecuacin sera : y y1 = m * ( x x1 ) , donde m es la pendiente de la recta y x1 e y1 son las coordenadas de un punto cualquiera de la misma. Para calcular m, se sabe tambin que: m= ( y2 y1 ) / ( x2 x1 ) , donde x1,y1 y x2,y2 son las coordenadas de dos puntos diferentes de la recta. Una vez obtenida la ecuacin, simplemente sera darle 20 valores diferentes a la x (Pueden ser aleatorios, consecutivos, etc.), para obtener sus valores en el eje y. Por lo anterior, se debe colocar la ecuacin de forma que la variable y quede totalmente despejada, o sea: y = [ ( y2 y1 ) / ( x2 x1 ) ] * ( x x1 ) + y1 INICIAR ( PRINCIPAL ) DECLARAR como NUMERO m , x1 , y1 , x2 , y2 , i , y READ(Digite la coordenada x del primer punto , x1 ) READ(Digite la coordenada y del primer punto , y1 ) READ(Digite la coordenada x del segundo punto , x2 ) READ(Digite la coordenada y del segundo punto , y2 ) m = ( y2 y1 ) / ( x2 x1 ) // se calcula la pendiente de la recta FOR i = 1 TO 20 // se escogen 20 valores sucesivos para la x (0,1,2,3,...20). y = m * ( i x1 ) + y1 // en este caso los valores para x, estn dados por i y se escoge // cualquiera de los 2 puntos digitados por el // usuario para usarlo en la ecuacin ( en este caso x1,y1 ). WRITE ( Punto: , i , , , y ) // La coordenada ser el punto ( i , y ) END FOR FIN ( PRINCIPAL ) 4.Anlisis: Un tringulo equiltero es aquel cuyos lados sonde igual longitud y adems sus ngulos internos son iguales ( 60 ), o sea que el usuario solo tendr que digitar cuanto vale la longitud de uno de los lados del tringulo, para conocer su forma.

Adems, el problema dice que uno de sus vrtices est en el punto 0,0 del plano cartesiano y uno de sus lados sobre el eje x, o sea que grficamente sera: y

2 L h ( 0,0 ) L 1

3 L x

Obsrvese que para la recta que llamamos 1, un punto sera el (0,0) y el otro punto sera ( L , 0 ), por lo que sera fcil hallar su ecuacin (Ver el ejercicio anterior). Lo nico que hay que tener en cuenta es que se piden 20 puntos de esa recta, o sea, que hay que dividir esa recta en 20 segmentos de forma que la escala para escoger los distintos valores de las x sea apropiada para que no se salga del tringulo. Es decir, para esta recta, ntese que las x se mueven entre 0 y L, o sea que para escoger 20 puntos, se comenzara desde 0 y se ira incrementando una cantidad de L / 20 de modo que cuando se llegue al ultimo punto (20), la x elegida no se pase de L. Para la recta 2, un punto sera el (0,0) y para hallar el otro punto usaremos lo que se conoce como la altura del tringulo, que es la recta h. sta recta, parte el lado 1 en dos semirectas iguales (cada una quedara midiendo L / 2 ) y forma un ngulo rectngulo con la base (Lado 1). Por lo que se puede ver, el tringulo formado por h, L2 y la mitad izquierda de L1es un tringulo rectngulo, por lo que se puede deducir la longitud de h por medio del teorema de pitagoras: L^2=H^2+(L/2)^2 h=[(L^2) - (L/2)^2] O sea que la x del segundo punto ser L / 2 y la y ser [ ( L ^ 2 ) - ( L / 2 ) ^ 2 ]. Conocidos estos dos puntos, se hace lo mismo que en el anterior, pero teniendo en cuenta que esta vez las x se mueven desde 0 hasta L / 2, por lo que para escoger 20 puntos se podra comenzar desde 0 e ir incrementando una cantidad de ( L / 2 ) / 20 , o sea L / 40. Entonces los dos puntos para la recta 3 sern ( L / 2 , [ ( L ^ 2 ) - ( L / 2 ) ^ 2 ] ) y (L , 0 ) , por lo que se hace lo mismo, aunque esta vez las x se mueven entre L / 2 y L , por lo que para escoger los 20 valores de x, se comienza desde L / 2 y se va incrementando una cantidad de ( L L / 2 ) / 20, o sea L / 40. INICIAR ( PRINCIPAL ) DECLARAR como NUMERO i , lado , m , x1 , y1 , x2 , y2 , incr READ(Digite la longitud de los lados del triangulo , lado ) x1 = y1 =0 x2 = lado y2 = 0 m = ( y2 y1 ) / ( x2 x1 ) // se calcula la pendiente de la recta 1 incr = L / 20 // incremento para los valores de la x en la recta 1 FOR i = 0 TO L STEP incr // los valores de x van desde 0 hasta L incrementndose L / 20. y = m * ( i x1 ) + y1 WRITE ( Punto: , i , , , y ) // La coordenada ser el punto ( i , y ) END FOR // ahora se hace lo mismo para le recta 2 x1 = y1 =0 x2 = lado / 2 y2 = RAIZ ( 2 , ( ( lado ) ^ 2 - ( lado / 2 ) ^ 2 ) ) m = ( y2 y1 ) / ( x2 x1 ) // se calcula la pendiente de la recta 2 incr = L / 40 // incremento para los valores de la x en la recta 2 FOR i = 0 TO L / 2 STEP incr // los valores de x van desde 0 hasta L / 2 incrementndose L / 40. y = m * ( i x1 ) + y1

WRITE ( Punto: , i , , , y ) // La coordenada ser el punto ( i , y ) END FOR // Por ultimo se hace para la recta 3 x1 = lado / 2 y1 = RAIZ ( 2 , ( ( lado ) ^ 2 - ( lado / 2 ) ^ 2 ) ) x2 = lado y2 = 0 m = ( y2 y1 ) / ( x2 x1 ) // se calcula la pendiente de la recta 3 incr = L / 40 // incremento para los valores de la x en la recta 3 FOR i = L / 2 TO L STEP incr // los valores de x van desde L / 2 hasta L incrementndose L /40. y = m * ( i x1 ) + y1 WRITE ( Punto: , i , , , y ) // La coordenada ser el punto ( i , y ) END FOR FIN ( PRINCIPAL ) UNIDAD 3: MANEJO DE GRUPOS DE DATOS CON VARIABLES SIMPLES Hasta el momento, solo se han diseado algoritmos para cuando el nmero de datos de entrada es conocido por el programador. Pero en la mayora de las ocasiones, el modelo que se est diseando requiere de un grupo de datos que son conocidos por el usuario y cuyo nmero depender de las necesidades especificas del mismo, por lo que no el programador no sabr explcitamente cuantos son los datos de entrada. Para el manejo de grupos de datos se ha hablado de dos formas de modelar los algoritmos: El modelo CUNTITATIVO y el modelo CUALITATIVO. 3.1. EL MODELO CUANTITATIVO Como su nombre lo indica, ste modelo se aplica cuando el usuario conoce el nmero exacto de datos, por lo que uno de los datos de entrada ser CUANTOS datos son. Despus de saber cuantos datos son, simplemente se efecta un ciclo FOR que se repita el nmero de veces especificado anteriormente pidindole al usuario que digite los datos uno por uno (Cada vez que se repita el ciclo), o sea que en total habrn CUANTOS + 1 datos de entrada en este modelo. Ejemplo: Disear un algoritmo que permita encontrar el promedio de una serie de datos cuyo nmero es conocido por el usuario. Anlisis: El nmero de datos es conocido por el usuario, por lo que se debe tener en cuenta como dato de entrada. Un promedio es la suma de todos los datos dividido el nmero de ellos, por lo que cada vez que se pida un dato al usuario se ir sumando (acumulando), y cuando finalice el ciclo, el resultado total se dividir por el nmero de datos.(Anteriormente digitado por el usuario).

INICIO ( PRINCIPAL ) DECLARAR como NUMERO numdatos , dato , suma , promedio , i READ (Por favor escriba el nmero de datos: , numdatos ) // Primero se pide el nmero de datos. suma = 0 // La suma comienza en cero, ya que no se ha sumado ningn dato por el momento. FOR i = 1 TO numdatos // El ciclo se repetir numdatos 1 + 1 veces = numdatos veces. READ (Escriba uno de los datos: , dato) // se pide un dato suma = suma + dato // se acumula en la suma ese dato END FOR // regresa al principio del ciclo para pedir otro dato.

promedio = suma / numdatos // divide la suma de todos los datos entre el nmero de los mismos. WRITE (El promedio es: , promedio ) FIN ( PRINCIPAL )