Programacion Teoria

FUNDAMENTOS DE INFORMÁTICA
PROGRAMACIÓN
INGENIERÍA MECÁNICA
INGENIERÍA ELÉCTRICA
Fundamentos de Informática
Programación
Indice
Resolución de problemas...............................................................................................................3
Introducción................................................................................................................................3
Resolución de problemas ...........................................................................................................3
Etapas en la resolución de problemas con computadora.............................................................3
1. análisis del problema...........................................................................................................3
2. Diseño de una solución .......................................................................................................3
3. Especificación de algoritmos ...............................................................................................4
4. Escritura de programas .......................................................................................................4
5. Verificación .........................................................................................................................4
Del detalle de las etapas anteriores puede observarse que: ....................................................4
Algoritmo....................................................................................................................................4
Definición................................................................................................................................4
Características de un algoritmo ...............................................................................................4
Pre y Poscondición de un algoritmo.........................................................................................6
Elementos que componen un algoritmo ......................................................................................6
Secuencia de Acciones ...........................................................................................................6
Selección ................................................................................................................................7
Estructura Repetitiva...............................................................................................................8
Repetición...............................................................................................................................8
Iteración..................................................................................................................................9
Importancia de la indentación en las estructuras de control ...................................................10
Síntesis ....................................................................................................................................11
Algoritmos Computacionales........................................................................................................12
Introducción..............................................................................................................................12
Descripción de los elementos presentes en el ejemplo ..........................................................12
Elementos de un algoritmo computacional................................................................................13
Constante .............................................................................................................................13
Variable ................................................................................................................................13
Nombres o identificadores.....................................................................................................13
Expresión..............................................................................................................................14
Tipos de Información ................................................................................................................14
Tipo Numérico.......................................................................................................................15
Tipo Caracter ........................................................................................................................17
Tipo Lógico ...........................................................................................................................18
Acciones Algorítmicas ..............................................................................................................20
Primitivas ..............................................................................................................................20
Acciones Primitivas de Estructura Secuencial .......................................................................21
Representación Gráfica de .......................................................................................................23
Algoritmos Computacionales ....................................................................................................23
Prueba de escritorio o seguimiento de algoritmos .....................................................................25
Síntesis ....................................................................................................................................26
Estructuras de control ..................................................................................................................28
Introducción..............................................................................................................................28
Estructura Básicas de Control...................................................................................................29
Estructura Secuencial ...........................................................................................................29
Estructura Condicional Si-Entonces.......................................................................................29
Estructuras de Control Adicionales ...........................................................................................34
Estructura Iterativa Repetir-Hasta que ...................................................................................38
Estructuras de control anidadas................................................................................................39
Síntesis ....................................................................................................................................41
ANEXO: Arreglos .........................................................................................................................42
Introducción:.............................................................................................................................42
Características de los Arreglos: ................................................................................................42
Arreglos Unidimensionales: ......................................................................................................43
Arreglos Multidimensionales: ....................................................................................................44
Página 2/44
Resolución de problemas
Introducción
El objetivo de este tema es introducir al lector en una metodología para abordar la resolución de
problemas mediante el empleo de algoritmos, los cuales permitirán -más adelante- construir programas
que pueden ser ejecutados por una computadora.
Como primera medida se empleará el concepto de algoritmo en forma general usando un lenguaje
natural para plantear pasos o acciones, y considerando que el ejecutor de tales acciones puede ser una
persona. Luego en la próxima unidad, se formalizará un lenguaje algorítmico planteando reglas
sintácticas similares a las de los lenguajes de programación de alto nivel que pueden ser interpretados
por una computadora.
El planteo sistemático de un método para la resolución de problemas es una buena práctica para
hallar la solución de problemas mediante algoritmos computacionales.
Resolución de problemas
Si se piensa en la forma en que una persona indica a otra cómo resolver un problema, se verá que
habitualmente se utiliza un lenguaje común y corriente para realizar la explicación, quizá entremezclado
con algunas palabras técnicas. Esto es un riesgo muy grande. Los que tienen cierta experiencia al
respecto saben que es difícil transmitir el mensaje y por desgracia, con mucha frecuencia se
malinterpretan las instrucciones y por lo tanto se “ejecuta incorrectamente" la solución, obteniéndose
errores.
Cuando de una computadora se trata, no pueden utilizarse indicaciones ambiguas. Ante cada orden
resulta fundamental tener una única interpretación de lo que hay que realizar. Una máquina no posee la
capacidad de decisión del ser humano para resolver situaciones no previstas.
Si al dar una orden a la computadora se produce una situación no contemplada, será necesario
abortar esa tarea y recomenzar todo el procedimiento nuevamente.
Además, para poder indicar a la computadora las órdenes que debe realizar es necesario
previamente entender exactamente lo que se quiere hacer. Es fundamental conocer con qué información
se cuenta y qué tipo de transformación se quiere hacer sobre ella.
A continuación se analizarán en forma general las distintas etapas que deben seguirse para poder
llegar a resolver un problema utilizando una computadora como herramienta.
Etapas en la resolución de problemas con computadora

La resolución de problemas utilizando como herramienta una computadora no se resume únicamente
en la escritura de un programa, sino que se trata de una tarea más compleja. El proceso abarca todos
los aspectos que van desde interpretar las necesidades del usuario hasta verificar que la respuesta
brindada es correcta. Las etapas son las siguientes:
1. análisis del problema

En esta primera etapa, se analiza el problema en su contexto del mundo real. Deben obtenerse los
requerimientos del usuario. El resultado de este análisis es un modelo preciso del ambiente del problema
y del objetivo a resolver. Dos componentes importantes de este modelo son los datos a utilizar y las
transformaciones de los mismos que llevan al objetivo.
2. Diseño de una solución

La resolución de un problema suele ser una tarea muy compleja para ser analizada como un todo.
Este aspecto puede facilitarse mediante la identificación de las partes (subproblemas) que componen el
problema y la manera en que se relacionan. Cada uno de estos subproblemas debe tener un objetivo
específico, es decir, debe resolver una parte del problema original. La unión de todos los subproblemas
es lo que permitirá obtener la solución buscada.
Página 3/44
3. Especificación de algoritmos
Cada uno de los subproblemas que componen la solución deben ser especificados a través de un
algoritmo. Esta etapa busca obtener la secuencia de pasos a seguir para resolver el problema. La
elección del algoritmo adecuado es fundamental para garantizar la eficiencia de la solución.
4. Escritura de programas
Un algoritmo es una especificación simbólica que debe convertirse en un programa real sobre un
lenguaje de programación concreto. A su vez, un programa escrito en un lenguaje de programación
determinado (ej: Pascal, Ada, C, C++, etc.) es traducido automáticamente al lenguaje de máquina de la
computadora que lo va a ejecutar. Esta traducción, permite detectar y corregir los errores sintácticos que
se cometan en la escritura del programa.
5. Verificación
Una vez que se tiene un programa escrito en un lenguaje real se debe verificar que su ejecución
conduce al resultado deseado, utilizando datos representativos del problema real. Será deseable poder
afirmar que el programa es correcto, más allá de los datos particulares de una ejecución. Sin embargo,
en los casos reales es muy difícil realizar una verificación exhaustiva de todas las posibles condiciones
de ejecución de un sistema de software. La facilidad de verificación y la depuración de errores de
funcionamiento del programa conducen a una mejor calidad del sistema y es un objetivo central de la
Ingeniería de Software.
Del detalle de las etapas anteriores puede observarse que:

El proceso de resolución de problemas utilizando una computadora como herramienta comienza y
termina con una etapa de análisis. La detección de errores en alguna de estas etapas puede llevar a
revisar aspectos de la solución analizados previamente.
La programación de la solución en un lenguaje específico es sólo una pequeña parte de toda la tarea
que hay que realizar.
Dada la sencillez de los problemas que vamos a resolver, la primera etapa correspondiente al análisis
del problema, sólo se verá reflejada en la interpretación del enunciado a resolver.
Con respecto a la segunda etapa, vamos a trabajar con problemas simples que no necesitan ser
descompuestos en otros más elementales.
Algoritmo
Es común encontrar el término de algoritmo como sinónimo de procedimiento, técnica o método.
Pero expresaremos su significado más específicamente.
Definición
Un algoritmo es un conjunto finito de pasos elementales (instrucciones-operaciones) que
seguidos en un determinado orden permiten resolver un problema.
Características de un algoritmo
Las características principales de todo algoritmo son:
FINITUD: permite arribar a la solución de un problema después de una cantidad finita de pasos.
Ejemplo :
Problema: Llene esta zanja con ese montón de arena.
Algoritmo: Tome una pala y empiece a echar arena en la zanja. Cuando se llene la zanja deténgase.
Se está seguro que en algún momento parará, aunque no se sabe cuanto tardará.
PRECISION: cada paso debe expresarse en forma clara y precisa y no debe dar lugar a
ambigüedades (si se trabaja dentro de cierto marco o contexto, cada instrucción del algoritmo debe
significar sólo una cosa.).
Página 4/44
Ejemplo :
Problema : Determinar si el número 7317 es primo.
Malo: Divida el 7317 entre sus anteriores buscando aquellos que lo dividan exactamente.
Bueno: Divida el número 7317 entre cada uno de los números 1, 2, 3, 4, ..., 7315, 7316. Si una de las
divisiones es exacta, la respuesta es no. Si no es así, la respuesta es sí.
Esta es una solución muy segura y no ambigua para este problema. Existen otros algoritmos mucho
más eficaces para dicho problema, pero esta es una de las soluciones correctas.
GENERALIDAD: la solución debe ser aplicable a un conjunto de problemas del mismo tipo y no a un
problema particular.
Ejemplo:
Problema: Hallar el área de un triángulo rectángulo, cuya altura es 10cm y su base 5cm.
Malo: Multiplicar 10 por 5 (Base por altura), Dividir 50 por 2 (área de un triángulo), Informar el valor
del cociente
Bueno: Conocer base y altura del triángulo, Multiplicar base por altura, Dividir el producto anterior por
2, Informar el valor del cociente.
Flexibilidad: permite abordar la solución de problemas similares con pequeños cambios.
Para comprender totalmente la definición anterior falta clarificar qué cosa es un paso elemental.
Ejemplo : Escriba un algoritmo que permita preparar una tortilla de papas de tres huevos.
El enunciado anterior basta para que un cocinero experto lo resuelva sin mayor nivel de detalle, pero
si este no es el caso, se deben describir los pasos necesarios para realizar la preparación.
Esta descripción puede ser:
Mezclar papas fritas, huevos y una pizca de sal en un recipiente.
Freír.
Esto podría resolver el problema, si el procesador o ejecutor del mismo no fuera una persona que da
sus primeros pasos en tareas culinarias, ya que el nivel de detalle del algoritmo presupone muchas
cosas.
Si este problema debe resolverlo una persona que no sabe cocinar, se debe detallar, cada uno de los
pasos mencionados, pues estos no son lo bastante simples para un principiante.
De esta forma, el primer paso puede descomponerse en:
Pelar las papas.
Cortarlas en cuadraditos.
Freír las papas.
Batir los huevos en un recipiente.
Verter las papas en un recipiente y echar una pizca de sal.
El segundo paso puede descomponerse en los siguientes tres:
Calentar el aceite en la sartén.
Verter el contenido del recipiente en la sartén.
Dorar la tortilla de ambos lados.
Nótese además, que si la tortilla va a ser realizada por un niño, algunas tareas (por ejemplo batir los
huevos) pueden necesitar una mejor especificación.
El ejemplo anterior sólo pretende mostrar que la lista de pasos elementales que compongan nuestro
algoritmo depende de quien sea el encargado de ejecutarlo.
Si en particular, el problema va a ser resuelto utilizando una computadora, el conjunto de pasos
elementales conocidos es muy reducido, lo que implica un alto grado de detalle para los algoritmos.
Se considera entonces como un paso elemental aquel que no puede volver a ser dividido en otros
más simples. De ahora en adelante se utiliza la palabra instrucción como sinónimo de paso elemental.
Página 5/44
Obsérvese que en la definición y en las características no se hace mención alguna de

resolución computacional de un algoritmo. Efectivamente, existen ciertos problemas cuya
solución algorítmica no requiere para su ejecución la presencia de una computadora. Por
ejemplo:
 Una receta de cocina.
 Un manual de instalación de un artefacto.
 La multiplicación de dos números.
 Comprar 1 Kg. de pan.
Como observación, se puede decir que un algoritmo debe estar expresado en un lenguaje
comprensible para el ejecutante. Y las acciones o pasos descriptos deben ser tales que el
ejecutante sea capaz de realizarlas.
También es observable que un problema determinado puede ser resuelto con varios algoritmos
diferentes. Es deseable encontrar una solución que resuelve el problema con un mínimo de
recursos y en el menor tiempo posible.
El ejecutante debe estar entrenado para reconocer y realizar las acciones descriptas. Los
algoritmos computacionales tienen la ventaja de proponer un conjunto de acciones, que
cualquier computadora puede ejecutar.
Pre y Poscondición de un algoritmo
Precondición es la información que se conoce como verdadera antes de comenzar el algoritmo.

Ejemplo :
Problema : Indique la manera de salar una masa.

Algoritmo: Agregarle una cucharadita de sal a la masa.
Se supone que se dispone de todos los elementos para llevar a cabo esta tarea. Por lo tanto, como
precondición puede afirmarse que se cuenta con la cucharita, la sal y la masa.
Poscondición es la información que se conoce como verdadera al concluir el algoritmo si se cumple
adecuadamente el requerimiento pedido.
Ejemplo :
Problema : Determinar si el número 7317 es primo.
Algoritmo: Divida el número 7317 entre cada uno de los números 1, 2, 3, 4, ..., 7315, 7316. Si una de
las divisiones es exacta, la respuesta es no. Si no es así, la respuesta es si.
La poscondición es que se ha podido determinar si el número 7317 es primo o no.
Problema: Llene esta zanja con ese montón de arena.
Algoritmo: Tome una pala y empiece a echar arena en la zanja. Cuando se llene la zanja deténgase.
¿cuáles serían la precondición y poscondición del algoritmo?
La precondición es que se cuenta con la pala, la arena y está ubicado cerca de la zanja que debe
llenar. Note que no es necesario que la zanja tenga capacidad para agregar alguna palada de arena para
que el algoritmo funcione. Por lo tanto, el estado de la zanja no forma parte de la precondición.
La poscondición es que la zanja estará tapada de arena al terminar el algoritmo.
Elementos que componen un algoritmo

Secuencia de Acciones
Una secuencia de acciones es un algoritmo, o una parte de un algoritmo, formado por una serie de
instrucciones que se ejecutan una a continuación de otra.
Ejemplo : Escriba un algoritmo que permita cambiar una lámpara quemada.
Colocar la escalera debajo de la lámpara quemada.
Página 6/44
 Elegir una lámpara nueva de la misma potencia que la anterior.

 Subir por la escalera hasta alcanzar la lámpara.
 Girar la lámpara quemada en sentido contrario al de las agujas del reloj, hasta que esté suelta.
 Ubicar la nueva en el mismo lugar.
 Enroscar en el sentido de las agujas del reloj hasta que quede apretada.
 Bajar de la escalera.
Ejemplo : Escriba un algoritmo que permita a un robot subir 8 escalones

 LevantaPieIzquierdo
 Subir un escalón
 LevantaPieDerecho
Se denomina flujo de control a través de un algoritmo al orden en el cual deben ejecutarse los pasos
individuales.
Hasta ahora se ha trabajado con el flujo de control lineal, o sea, la ejecución secuencial de pasos,
desde el primero hasta el último.
Las estructuras de control son construcciones algorítmicas que alteran directamente el flujo de control
lineal del algoritmo.
Con ellas es posible seleccionar un determinado sentido de acción de entre un par de alternativas
específicas o repetir automáticamente un grupo de instrucciones.
A continuación se presentan las estructuras de control necesarias para la resolución de problemas
más complejos.
Selección
La escritura de soluciones a través de una secuencia de órdenes requiere conocer a priori las
diferentes alternativas que se presentarán en la resolución del problema. Lamentablemente, es imposible
contar con esta información antes de comenzar la ejecución de la secuencia de acciones.
Por ejemplo, que ocurrirá si en el ejemplo que pide que se cambie una lámpara, al querer sacar la
lámpara quemada, el portalámpara se rompe. Esto implica que el resto de las acciones no podrán
llevarse a cabo por lo que el algoritmo deberá ser interrumpido. Si se desea que esto no ocurra, el
algoritmo deberá contemplar esta situación. Nótese que el estado del portalámpara es desconocido al
iniciar el proceso y sólo es detectado al intentar sacar la lámpara quemada. Por lo que el solo uso de la
secuencia es insuficiente para expresar esta solución.
A través de la selección se incorpora, a la especificación del algoritmo, la capacidad de decisión. De
esta forma será posible seleccionar una de dos alternativas de acción posibles durante la ejecución del
algoritmo.
Por lo tanto, el algoritmo debe considerar las dos alternativas, es decir, qué hacer en cada uno de los
casos. La selección se notará de la siguiente forma:
Página 7/44
Si (condición) entonces
acción o acciones a realizar si la condición es verdadera (1)
sino
acción o acciones a realizar si la condición es falsa (2)
donde condición es una expresión que al ser evaluada puede tomar solamente uno de dos valores
posibles: verdadero o falso.
El esquema anterior representa que en caso de que la condición a evaluar resulte verdadera se
ejecutarán las acciones de (1) y NO se ejecutarán las de (2). En caso contrario, es decir si la condición
resulta ser falsa, sólo se ejecutarán las acciones de (2).
En la figura se grafica la selección utilizando un rombo para representar la decisión y un rectángulo
para representar un bloque de acciones secuenciales.
Analice el siguiente ejemplo:

Su amigo le ha pedido que le compre $1 de caramelos en el kiosco. De ser posible, prefiere que sean
de menta pero si no hay, le da igual que sean de cualquier otro tipo. Escriba un algoritmo que represente
esta situación.
Ir al kiosco
Si (hay caramelos de menta) entonces
Llevar caramelos de menta (1)
sino
Llevar de cualquier otro tipo (2)
Pagar 1 peso
Los aspectos más importantes son:

No es posible saber si en el kiosco hay o no hay caramelos de menta ANTES de llegar al kiosco por
lo que no puede utilizarse únicamente una secuencia de acciones para resolver este problema.
La condición “hay caramelos de menta" sólo admite dos respuestas posibles: hay o no hay; es decir,
verdadero o falso respectivamente.
Si se ejecuta la instrucción marcada con (1), NO se ejecutará la acción (2) y viceversa.
Independientemente del tipo de caramelos que haya comprado, siempre se pagará $1. Esta acción es
independiente del tipo de caramelos que haya llevado.
En algunos casos puede no haber una acción específica a realizar si la condición es falsa. En ese
caso se utilizará la siguiente notación:
Si (condición) entonces
acción o acciones a realizar en caso de que la condición sea verdadera.
Ejemplo : Su amigo se ha puesto un poco más exigente y ahora le ha pedido que le compre $1 de
caramelos de menta en el kiosco. Si no consigue caramelos de menta, no debe comprar nada.
Escriba un algoritmo que represente esta situación.
Ir al kiosco
Si (hay caramelos de menta) entonces
Llevar caramelos de menta
Pagar 1 peso
Con este último algoritmo, a diferencia del anterior, si la condición “hay caramelos de menta" resulta
ser falsa, no se realizará ninguna acción.
Estructura Repetitiva
Repetición
Un componente esencial de los algoritmos es la repetición. La computadora, a diferencia de los
humanos, posee una alta velocidad de procesamiento. A través de ella, es posible ejecutar, de manera
Página 8/44
repetitiva, algunos pasos elementales de un algoritmo. Esto puede considerarse una extensión natural de
la secuencia.
La repetición es la estructura de control que permite al algoritmo ejecutar un conjunto de instrucciones
un número de veces fijo y conocido de antemano.
La notación a utilizar es la siguiente:
repetir N
acción o acciones a realizar N veces.
Se analizan a continuación algunos algoritmos que tienen repeticiones.

Ejemplo : Escriba un algoritmo que permita poner 4 litros de agua en un balde utilizando un vaso de
50 cc.
Se observa que hay dos pasos básicos: llenar el vaso con agua y vaciarlo en el balde. Para completar
los cuatro litros es necesario repetir estas dos operaciones ochenta veces.
Tomar el vaso y el balde (se supone que hay una canilla cerca)
Repetir 80
Llenar el vaso de agua.
Vaciar el vaso en el balde.
Dejar el vaso
Nótese que, la instrucción “Dejar el vaso" no pertenece a la repetición. Esto queda indicado por la
sangría o indentación utilizada para cada instrucción.
El ejemplo del robot, que inicialmente se presentó como un ejemplo de secuencia, puede escribirse
utilizando una repetición de la siguiente forma:
Ejemplo : Escriba un algoritmo que permita a un robot subir 8 escalones.

repetir 4
LevantaPieIzquierdo
Subir un escalón
LevantaPieDerecho
Subir un escalón
Este algoritmo realiza exactamente las mismas acciones que el algoritmo del ejemplo anterior. Las
ventajas de utilizar la repetición en lugar de la secuencia son: la reducción de la longitud del código y la
facilidad de lectura.
Ejemplo : Juan y su amigo quieren correr una carrera dando la vuelta a la manzana. Considerando
que Juan vive en una esquina, escriba el algoritmo correspondiente.
Repetir 4
Correr una cuadra
Doblar a la derecha
Iteración
Existen situaciones en las que se desconoce el número de veces que debe repetirse un conjunto de
acciones. Por ejemplo, si se quiere llenar una zanja con arena utilizando una pala, será difícil indicar
exactamente cuántas paladas de arena serán necesarias para realizar esta tarea. Sin embargo, se trata
claramente de un proceso iterativo que consiste en cargar la pala y vaciarla en la zanja.
Por lo tanto, dentro de una iteración, además de una serie de pasos elementales que se repiten; es
necesario contar con un mecanismo que lo detenga.
La iteración es una estructura de control que permite al algoritmo ejecutar en forma repetitiva un
conjunto de acciones utilizando una condición para indicar su finalización.
El esquema iterativo es de la forma:
Página 9/44
Mientras (condición)
acción o acciones a realizar en caso de que la condición sea verdadera.
La condición utilizada en esta oportunidad es de la misma forma que la vista en la selección; es decir,
se trata de una expresión que puede tener sólo uno de dos valores posibles: verdadero o falso.
Las acciones contenidas en la iteración serán ejecutadas mientras la condición sea verdadera. Es
importante notar que, la primera vez, antes de ejecutar alguna de las acciones de la iteración, lo primero
que se realiza es la evaluación de la condición. sólo luego de comprobar que es verdadera se procede a
ejecutar el conjunto de acciones pertenecientes al mientras.
Si inicialmente la condición resultara falsa, el contenido del mientras no se ejecutará ni siquiera una
sola vez.
Es importante que las acciones realizadas en el interior de la iteración modifiquen el valor de verdad
de la condición para garantizar que la iteración terminará en algún momento.
Ejemplo : Escriba un algoritmo que permita llenar una zanja con arena utilizando una pala.
Tomar la pala.
Ubicarse frente a la zanja.
Mientras (la zanja no esté llena)
agregar una palada de arena.
Dejar la pala.
La iteración indica que, mientras no se complete la zanja, se seguirá incorporando arena. Cuando la
zanja se llene, la condición será falsa y la iteración terminará. Es importante destacar, que si la zanja
inicialmente ya estaba llena, ninguna palada de arena será incorporada a dicha zanja. Es decir, la
condición se verifica ANTES de comenzar la iteración.
En este punto es apropiado hacerse la siguiente pregunta. ¿qué sentido tiene introducir el concepto
de iteración? Con toda seguridad, para los ejemplos antes mencionados no es necesario dicho concepto
para establecer clara, simple o comprensiblemente las instrucciones del algoritmo.
Existe una razón bastante obvia para justificar este método: es una realidad el hecho de que las
computadoras requieren instrucciones bastante detalladas acerca de lo que deben hacer. Se debe, por lo
tanto, desmenuzar los algoritmos en pasos simples, de modo que las computadoras puedan efectuar sus
cálculos. Si se quiere que algo sea realizado 80 veces, se debe decir a la máquina que quiere que lo
repita 80 veces. El empleo de las instrucciones de iteración permite hacer esto sin tener que escribir 80
líneas de instrucciones de máquina.
Esta razón, tan obvia, oscurece la causa importante del porqué se estudia la iteración. El concepto de
iteración es necesario para la claridad del pensamiento en el estudio de los procesos algorítmicos. La
iteración es un proceso fundamental en los algoritmos, y se debe ser capaz de pensar en términos de
ciclos de iteración, para poder construir los algoritmos.
Importancia de la indentación en las estructuras de control

Las instrucciones que pertenecen a una estructura de control deben tener una sangría mayor que la
utilizada para escribir el comienzo de la estructura. De esta forma, podrá identificarse donde termina el
conjunto de instrucciones involucradas. A esta sangría se la denomina indentación.
Este concepto se aplica a la tres estructuras de control vistas previamente: selección, repetición e
iteración.
El siguiente ejemplo muestra el uso de la indentación en la selección:
Ejemplo : Se desea colgar un cuadro en una pared (incluyendo la colocación del clavo). Como la
pared se encuentra en un estado muy precario puede ocurrir que el clavo no quede firme. De ser así se
procederá a masillar el agujero y el cuadro quedará sin colgar.
Escriba el algoritmo que resuelva este problema.
Tomar martillo y clavo.
Pararse frente al lugar donde se desea colgar el cuadro.
Colocar el clavo.
Si (el clavo quedó firme) entonces (1)
Traer el cuadro
Página 10/44
Ponerlo en su sitio
Sino
Retirar el clavo
Masillar el agujero
Guardar las herramientas (2)
Como puede apreciarse, las acciones que deben ser realizadas cuando la condición es verdadera se
encuentran desplazadas un poco más a la derecha que el resto de la estructura. Algo similar ocurre con
las acciones a realizar cuando la condición es falsa. De esta forma puede diferenciarse lo que pertenece
a la selección del resto de las instrucciones.
En el ejemplo anterior, la instrucción “Guardar las herramientas" se realiza siempre sin importar si el
cuadro fue colgado o no. Esto se debe a que no pertenece a la selección. Esto queda de manifiesto al
darle a las instrucciones (1) y (2) la misma indentación.
Síntesis
Las etapas para la resolución de problemas constituyen una forma sistemática de plantear soluciones
algorítmicas a dichos problemas y resolver los casos propuestos.
Es fundamental entender claramente lo que plantea el problema, conocer los datos, los resultados a
obtener y las relaciones entre datos y resultados (1ra etapa: Análisis), seleccionar un solución al
problema (2da etapa: Diseño de la solución).
La tercera etapa para la resolución de problemas es la Especificación de Algoritmos y en ella se

plantea el algoritmo. Para codificar un algoritmo se debe utilizar un lenguaje adecuado que describa las
acciones o pasos a realizar. Ese lenguaje está ligado al ejecutante encargado de procesar las acciones.
El objetivo de esta asignatura es aprender a construir algoritmos computacionales por lo cual nos
centraremos en esta etapa.
Se puede escribir un algoritmo usando nuestro lenguaje natural. Ese algoritmo podrá ser ejecutado
por una persona la cual entiende nuestro lenguaje (y que sepa cómo realizar cada acción). En tal caso
se está en presencia de un algoritmo no computacional.
Al escribir un algoritmo usando un lenguaje similar al que puede interpretar una computadora se está
en presencia de un algoritmo computacional. Si usamos un lenguaje de programación, el algoritmo
constituye un programa.
Un algoritmo debe:
completar siempre un número determinado de pasos durante su ejecución, independientemente de
los datos del problema (Finitud).
tener acciones que puedan ser interpretadas por el ejecutante sin dar lugar a ambigüedades
(Precisión).
resolver un grupo de casos similares o de igual tipo (Generalidad).
Al ejecutar un algoritmo estamos realizando la prueba del mismo (5ta etapa: Verificación). Si se
detectan errores se deben corregir o depurar .
Página 11/44
Algoritmos Computacionales
Introducción
Los problemas y algoritmos desarrollados en la unidad anterior, reflejan situaciones de la vida
diaria. En la mayoría de los casos fueron planteados para que los resuelva o ejecute una
persona.
Pero el objetivo es desarrollar algoritmos que pueden ser interpretados por una computadora.
Para ello es necesario utilizar un lenguaje que interprete una computadora y que permita una
descripción precisa de cada una de las acciones a emplear en la solución del problema.
Esta unidad propone describir la formalización necesaria para el desarrollo de Algoritmos

Computacionales empleando un pseudolenguaje similar a los empleados en la confección de
programas..
De aquí en más, cuando se mencione al ejecutante de un algoritmo, se estará haciendo
referencia a una computadora.
En el ejemplo que se propone a continuación se desarrolla un algoritmo completo de acuerdo a

la formalización que se propone.
Ejemplo
Problema: plantear un algoritmo computacional que calcule la hipotenusa de un triángulo
rectángulo. Se conoce como información de entrada las longitudes de los catetos.
Análisis del Problema:

Datos: Longitudes de los catetos.
Resultado a informar: Hipotenusa.
Relaciones entre datos y resultados: Teorema de Pitágoras.
Algoritmo:
Proceso Hipotenusa
Leer A,B;
H  RC(A2+B2);
Escribir 'Hipotenusa =',H;
FinProceso
Descripción de los elementos presentes en el ejemplo

En el ejemplo A, B y H constituyen identificadores de variables; 2 e 'Hipotenusa' son
constantes; Leer, Escribir y  son las acciones primitivas de la lectura, escritura y asignación
respectivamente; RC(A  2 + B  2) es una expresión numérica y RC ( ) es la función cuadrada.
En esta unidad se desarrollarán todos estos elementos que conforman un lenguaje algorítmico
formal que llamado pseudocódigo.
Página 12/44
La forma general de un algoritmo escrito en pseudocódigo es la siguiente:
PROCESO nombre del proceso

acción 1;
acción 2;
.
.
.
FINPROCESO
Elementos de un algoritmo computacional

Constante
Se define constante, como el valor que no puede alterarse en el transcurso de un algoritmo.
Ejemplos de constantes:
123 'López' Falso 3.1459
Esta información se expresa mediante un valor intrínseco y único que no puede alterarse. Se
utilizarán con frecuencia estos datos para asignarlos a variables o construir expresiones.
Variable
Una variable es una posición de memoria capaz de almacenar un único valor por vez. A
medida que se ejecuten las acciones que describe el algoritmo esa variable podrá representar
a nuevos valores. En un algoritmo una variable se referencia a través de nombres o
identificadores.
En el ejemplo inicial del cáclculo de la hipotenusa:
Proceso Hipotenusa
Leer A,B;
H  RC(A2+B2);
Escribir 'Hipotenusa =',H;
FinProceso
se observa que 2 e ‘Hipotenusa=’ constituyen constantes. A, B H son variables.
Nombres o identificadores
Para proponer el nombre o identificador de algún elemento del algoritmo -como las variables- el
diseñador tiene amplia libertad y solo debe respetar tres reglas simples:
Página 13/44
1) Utilizar sólo letras y/o dígitos, comenzando siempre con una letra.
2) No utilizar palabras claves para acciones primitivas que emplea el pseudocódigo: LEER,
ESCRIBIR, MIENTRAS, HACER, SEGUN, etc., o para las funciones internas: RC, SEN,
TRUNC, LN, etc., o las palabras que corresponden a las constantes lógicas VERDADERO y
FALSO
3) No hacer distinción entre mayúsculas y minúsculas. Esto implica que VENTA, venta y Venta,
constituyen en el algoritmo el mismo nombre.
Esta sintaxis y sus restricciones no representan inconvenientes para proponer nombres de

cualquier elemento del algoritmo: variables, algoritmos, procedimientos, funciones, archivos;
pues se dispone de un sinnúmero de combinaciones diferentes de letras y dígitos.
Ejemplos de identificadores:
venta x12 resultado SUMA2 M3M
Se mencionó que el diseñador del algoritmo tiene total libertad para proponer nombres a sus
elementos, aunque como consejo, es conveniente proponer identificadores que tengan alguna
relación con lo que el elemento representa.
En nuestro ejemplo inicial del cálculo de la hipotenusa de un triángulo rectángulo, se podría
haber empleado los nombres de variables CATETO1, CATETO2, HIPOT, en lugar A, B, H.
Expresión
Se define como expresión a un conjunto de operandos ligados por operadores cuya evaluación
arroja un resultado.
En el ejemplo incial RC(A  2 + B  2) es una expresión numérica (relación de Pitágoras) que
permite calcular el valor de la hipotenusa.
Ejemplos de expresiones:
2+a-x*5 45 A < B TRUNC(R) + 1
Tipos de Información
Se puede clasificar la información que puede manejar una computadora a través de un
algoritmo en los tipos siguientes:
 tipo NUMERICO
Página 14/44
 tipo CARACTER
 tipo LOGICO
Esta clasificación nos define los tipos primitivos de la información. Se estudiará a cada uno de
ellos y su modo de empleo.
Tipo Numérico
Constantes Numéricas
Los valores o constantes de tipo numérico son decimal y pueden estar precedidos por los
signos '+ o '-' . La ausencia de signo implica un número positivo. Se pueden subdividir en
reales y enteros, o admitir clasificaciones más detalladas, de acuerdo al lenguaje de
programación empleado. Para la formalización propuesta mediante el empleo de un
pseudocódigo universal, no se harán distinciones de esta clase y simplemente se hablará de
tipo numérico.
Un detalle importante: los números reales deben separar su parte entera de la fracción decimal
con un punto en lugar de la coma. Se reserva la coma como separador. No se utilizará ningún
símbolo para separación de miles.
Ejemplos de constantes numéricas:
14 -12500 +1.9452 -567.91 1.3E+2 -0.94E-3
En los 2 últimos ejemplos se indican constantes numéricas con notación científica. Donde la
cifra a la derecha de la E indica el exponente de la potencia de base 10. Es decir: 1.3 E+2 =
1.3*102 = 130
Variables Numéricas
Una posición de memoria, que contenga cualquier valor de tipo numérico se denomina Variable
Numérica. Las variables se identifican en un algoritmo a través de nombres o identificadores.
Expresiones Numéricas
Las expresiones numéricas se plantean en general con constantes numéricas, variables
numéricas y funciones; y los operadores algebraicos como nexo:
Operadores algebraicos
+ : suma
- : resta
* : multiplicación
/ : división
 : potenciación
Página 15/44
Es de mencionar que ciertos lenguajes de programación no disponen de todos los operadores

antes descritos, así como es posible hallar otros operadores algebraicos adicionales a los
presentados.
La jerarquía de estos operadores es idéntica a la planteada por el álgebra de números y sólo
puede ser alterada a través de la intercalación de niveles de paréntesis.
Ejemplos de expresiones numéricas
2+a*102-800/C
1-(2*TOT-30 )(1+P)
AREA*(Y+1.34 /(X2-T ))
Obsérvese que el operador de radicación no existe; pero esto no es un problema porque esta
operación puede plantearse fácilmente a través de la potenciación de exponente fraccionario:
m
n
am  a n
De todas maneras es común hallar en casi todos los lenguajes de programación una función
que realiza el cálculo de la raíz cuadrada. En pseudocódigo se utiliza para el ejemplo inicial y
se llama RC( ).
Además se asume que el ejecutante del algoritmo, conoce y puede resolver ciertas funciones
numéricas. A estas funciones se las llama funciones predefinidas y tienen la propiedad de
devolver un valor o resultado, al ser aplicadas sobre un argumento que se indica entre
paréntesis.
Funciones Predefinidas
Algunas de las funciones predefinidas que incluye el pseudocódigo:
RC( ) : Raíz cuadrada
ABS( ) : Valor absoluto
LN( ) : Logaritmo natural
EXP( ) : Función exponencial
SEN( ) : Seno de un ángulo en radianes
COS( ) : Coseno de un ángulo en radianes
ATAN( ) : Arco Tangente del argumento
TRUNC( ) : Parte entera del argumento
REDON( ) : Entero mas cercano
Con estos nuevos elementos, se puede ampliar el uso de expresiones numéricas.
Ejemplos de expresiones numéricas
TRUNC(2/3)-ABS(X)-2*(X-1)
Página 16/44
SEN(X)+1-TAN(C/2)
(-b+RC(b*b-4*a*c))/(2*a)
Nota: Los lenguajes de programación suelen disponer de un número mucho mayor de
funciones predefinidas.
Tipo Caracter
Constantes Tipo Caracter

Se incluyen aquí a todos los caracteres y símbolos del código ASCII (Código Standard
Americano para Intercambio de Información), los cuales pueden obtenerse de las teclas o
combinaciones de teclas de su computadora, es decir, las letras del alfabeto en minúsculas y
las letras mayúsculas, los signos de puntuación, los operadores aritméticos, paréntesis, el
espacio en blanco, caracteres especiales, etc.
También se incluyen dentro de este tipo a las cadenas de caracteres, como los apellidos,
nombres, direcciones y también cadenas de caracteres numéricos:
Ejemplos de constantes tipo carácter
'Luis Rodríguez' 'Z' 'Resultado='

'25 de Mayo' '3124' '123/890-12'
Importante: En este tipo de información: el conjunto de caracteres ASCII, es un conjunto

ordenado, y por tanto existe una relación de precedencia u orden entre sus elementos. Cada
elemento del conjunto tiene un número de orden en lo que se conoce como tabla o código
ASCII, y ese número es el que determina la relación de orden:
El código ASCII se ha convertido en un standard mundial que permite compatibilizar la

información que manejan las computadoras.
La siguiente tabla muestra algunos de los caracteres del código ASCII y su correspondiente
número de orden. En total son 255 caracteres.
32 '' 48 '0' 64 '@' 80 'P' 96 '`' 112 'p'

33 '!' 49 '1' 65 'A' 81 'Q' 97 'a' 113 'q'
34 '"' 50 '2' 66 'B' 82 'R' 98 'b' 114 'r'
35 '#' 51 '3' 67 'C' 83 'S' 99 'c' 115 's'
36 '$' 52 '4' 68 'D' 84 'T' 100 'd' 116 't'
37 '%' 53 '5' 69 'E' 85 'U' 101 'e' 117 'u'
38 '&' 54 '6' 70 'F' 86 'V' 102 'f' 118 'v'
39 ''' 55 '7' 71 'G' 87 'W' 103 'g' 119 'w'
40 '(' 56 '8' 72 'H' 88 'X' 104 'h' 120 'x'
Página 17/44
41 ')' 57 '9' 73 'I' 89 'Y' 105 'i' 121 'y'

42 '*' 58 ':' 74 'J' 90 'Z' 106 'j' 122 'z'
43 '+' 59 ';' 75 'K' 91 '[' 107 'k' 123 '{'
44 ',' 60 '<' 76 'L' 92 '\' 108 'l' 124 '|'
45 '-' 61 '=' 77 'M' 93 ']' 109 'm' 125 '}'
46 '.' 62 '>' 78 'N' 94 '^' 110 'n' 126 '~'
47 '/' 63 '?' 79 'O' 95 '_' 111 'o' 127 ' '
Si se tiene en cuenta la relación de orden dada por el código ASCII se puede afirmar que son
verdaderas las expresiones siguientes:
La letra 'a' es mayor que la letra 'B'.

(‘a’ tienen número de orden 97 que es mayor al 66 de la ‘B’)
El caracter '5' es menor que la letra 'A'.

(el carácter ‘5’ tiene código 53 y el de la letra ‘A’ es 65)
La cadena de caracteres 'Mario' es menor que ‘Roberto’.

(se encuentra antes alfabéticamente)
Se observa que a las constantes tipo caracter o las cadenas de caracteres se indican entre
apóstrofos o simples comillas. Esto es para evitar confundir estos datos con identificadores
de otros elementos del algoritmo. Por ejemplo, 'A' es un dato tipo caracter y A un identificador
de un elemento del algoritmo.
Variables Tipo Caracter

Una posición de memoria, que contenga cualquier dato de tipo caracter o cadena de caracteres
se denomina Variable Tipo Caracter.
Expresiones Tipo Caracter

En el pseudolenguaje que se empleará en esta primer parte de Fundamentos de Programación
no se utilizarán operadores ni funciones para el manejo de caracteres y cadenas de caracteres.
Por lo que las expresiones de este tipo quedan reducidas a simples constantes o variables.
Tipo Lógico
Constantes de Tipo Lógico
Dentro de este tipo se incluye a solo dos constantes o valores posibles: VERDADERO y
FALSO. Esto implica tener en cuenta una nueva limitación al proponer identificadores: no
pueden utilizarse los nombres VERDADERO y FALSO para evitar ambigüedades.
Variables Lógicas
Página 18/44
Una posición de memoria, que contenga cualquier dato de tipo lógico es una Variable Lógica.
Expresiones Lógicas
Aquí cobran mucha importancia una serie de operadores que nos permiten plantear
expresiones de tipo lógico. Las expresiones mas simples son las relacionales que utilizan los
operadores relacionales matemáticos para comparar operandos de igual tipo.
Operadores relacionales
Operador Significado
--------------- ------------------
> Mayor que
< Menor que
= Igual que
<= Menor o igual que
>= Mayor o igual que
<> Distinto que
Ejemplos de expresiones lógicas relacionales
23<45 A+2>=100 'a'<>LETRA
'ANA'<'LUIS' (2+B) >=Trunc(2+B) 7>'M'
Las expresiones lógicas simples mostradas en el ejemplo se conocen como expresiones

relacionales, pues permiten comparar o relacionar a 2 operandos del mismo tipo.
Justamente, la ultima expresión del ejemplo anterior no es valida, pues compara a una
expresión numérica con un caracter.
La algorítmica computacional, permite también formar expresiones lógicas mas complejas a

través de los conectores que emplea la lógica proposicional:
Operadores lógicos
Operador Significado
--------------- ------------------
 Disyunción
 Conjunción
~ Negación
Página 19/44
Se observa entonces el valor de verdad de las expresiones lógicas propuestas en el ejemplo

siguiente:
Ejemplo:
Expresión Lógica Resultado
-------------------------------------- -------------------------
(7<10)  ('a'<'c') VERDADERO
('A'<'a')  (12>19) VERDADERO
( 37<18 ) FALSO
( SEN(x)<=1 ) VERDADERO
('MARIA'<'MARTA') VERDADERO
('MARIA'<'MARTA')  (1>2) FALSO
Acciones Algorítmicas
Primitivas
En el lenguaje algorítmico (pseudocódigo), las primitivas se identifican con palabras claves o
reservadas.
Se han empleado en el ejemplo inicial las primitivas: LEER, ESCRIBIR y  (asignar).
La ejecución de las acciones primitivas de un algoritmo suele ser diferente según el caso, lo
cual lleva a plantear la siguiente clasificación:
Primitivas de Estructura Secuencial
Primitivas de Estructura Condicional

Primitivas de Control
Primitivas de Estructura Repetitiva
En la próxima unidad se desarrollarán las estructuras algorítmicas de control que implican el

uso de primitivas de estructura condicional y de estructura repetitiva.
Se plantea a continuación, algunas acciones de estructura secuencial.
Página 20/44
Acciones Primitivas de Estructura Secuencial
Asignación
Esta acción, permite a un identificador de variable, representar o memorizar cierto valor. Para
describirla se utilizará la notación siguiente:
V  E;
Donde V es el nombre de la variable ( o simplemente la variable ) a la cual el ejecutante debe
asignar el valor de la expresión E. El símbolo ' ' puede leerse toma el valor.
Los tipos de V y E deben ser coincidentes, en caso contrario será causa de error. Según el tipo
de V y E una asignación puede ser:
 Asignación numérica.
 Asignación tipo caracter.
 Asignación lógica.
Si V es una variable numérica y E cualquier expresión de tipo numérica la asignación es

numérica.
Ejemplos de Asignaciones Numéricas
A  43; ( A toma el valor 43 )
X  A; ( X toma el valor contenido en A )
NUM  3*X/A+2; ( NUM toma el valor del resultado de

hacer 3*X/A+2 )
Importante: Nótese que para poder realizar una asignación aritmética se debe evaluar
primero la expresión de la derecha, por lo tanto es perfectamente válida la acción: NN+1;
que puede leerse: tomar el valor actual de N, sumarle 1, y asignar ese resultado a la variable
N. Por ejemplo, si antes de la acción, N contenía el valor 8, luego de dicha acción contendrá
9. Obsérvese que esta acción algorítmica no tiene nada que ver con los conceptos asimilados
en matemáticas, donde N=N+1 es una expresión incompatible.
Del mismo modo se definen las asignaciones tipo caracter y tipo lógica.
Ejemplos de Asignaciones tipo caracter
LETRA  'A'; ( LETRA toma el valor 'A' )

X3  A; ( X toma el valor contenido en A )
Página 21/44
NOMBRE 'Jorge'; ( NOMBRE toma el valor de 'Jorge' )
Ejemplos de Asignaciones Lógicas
M  FALSO; //M toma el valor FALSO

CIERTO  34 <= 78 ; //CIERTO toma el valor VERDADERO
G (A<2)  (C=10); //G toma el valor lógico
// resultante de la expresión (A<2)  (C=10) )
Entrada
Todo algoritmo tiene por objetivo principal producir resultados, pudiendo o no incorporar
información del medio externo (datos), al ambiente o sistema que observa. Esta incorporación
de valores desde el exterior, nos lleva a definir una acción algorítmica primitiva de Lectura
o Entrada. Se usará para ello la palabra clave LEER que permitirá al ejecutante identificar
esta acción, seguida de la variable o lista de variables, que representan en el algoritmo la los
valores que deben ser ingresados.
Ejemplos de entrada de datos
LEER Dat;
LEER Nombre, Apellido, DNI;
Esta acción tiene el mismo efecto que una asignación, solo que esta última utiliza valores del
ambiente del algoritmo; en cambio la lectura asigna valores desde el exterior.
También esta acción contribuye a hacer a los algoritmos de uso general, pues permite
incorporar información nueva para producir nuevos resultados. Sin esta acción, la ejecución de
un algoritmo producirá siempre la misma respuesta.
Las acciones de lectura y asignación permiten definir variables en un algoritmo.
Salida
La acción primitiva que permite a un algoritmo comunicar resultados o salida de información al
medio exterior, se representará con la palabra clave ESCRIBIR; y a continuación una variable,
una constante, una lista de variables y/o constantes o expresiones.
Ejemplos
ESCRIBIR Dat, Nombre;
ESCRIBIR 23;
ESCRIBIR 'Dato=',X;
ESCRIBIR 'Resultado=',3*X+(X-1)/2;
Página 22/44
Se destacan algunas diferencias entre las acciones de lectura y escritura. La lectura se realiza
solamente a través de variables; y por lo tanto, si se lee una variable que ya fue definida en el
algoritmo, implicara un acceso destructivo; esto es, la variable perderá su valor para tomar el
del nuevo dato que se ingresa. En cambio, si se escriben resultados a través de variables el
ejecutante realizara un acceso no destructivo a dichas variables, pues solo necesita conocer su
contenido, para ejecutar la escritura. Aquí las variables conservan sus valores después de la
acción.
En el ejemplo inicial para calcular la hipotenusa la expresión utilizada era:
H  RC(A2+B2); en ese caso se accede a los valores A y B en forma no destructiva (se
usan sus valores para el cálculo sin modificarlos).
Las acciones de lectura y escritura son conocidas como acciones de entrada/salida o
abreviadamente E/S.
Representación Gráfica de
Algoritmos Computacionales
Las acciones descritas antes corresponden a un lenguaje algorítmico denominado
pseudocódigo. El pseudocódigo es una de las formas que se puede emplear para representar
algoritmos. Además, se diseñarán algoritmos en forma gráfica a través de los llamados
diagramas de flujo.
En un diagrama de flujo, las estructuras de las primitivas del pseudocódigo se representan con
una forma geométrica identificatoria o bloque. Estos bloques se unen con flechas que nos
indican la secuencia u orden en que deben ejecutarse las instrucciones, es decir el flujo o
recorrido que ha de seguirse en el diagrama.
Por ejemplo, para las acciones de lectura y escritura se empleará un paralelogramo con una
pequeña flecha que apunta hacia adentro o hacia afuera del bloque, respectivamente. Para la
acción de asignación, se utilizará un rectángulo.
Una de las ventajas del empleo de diagramas de flujo, es la visualización plana de las acciones
que forman el algoritmo, permitiendo seguir fácilmente su lógica. Estas ventajas se
apreciaran mas adelante, cuando se describan primitivas de estructura condicional y
repetitiva.
Se observan ahora, algunas de las formas geométricas que identifican acciones en un
diagrama de flujo. En las próximas unidades se incorporarán nuevas acciones con su
simbología correspondiente:
Inicio o fin de proceso Asignación
Escritura o salida de información Lectura o entrada de datos
Página 23/44
V F
Estructura condicional Si-entonces
Ejemplo
Problema: Intercambiar los valores de 2 variables numéricas que se leen como datos.
Algoritmo ( en pseudocódigo )
Proceso Intercambio
Leer A,B;
AUX  A;
A  B;
B  AUX;
Escribir A,B;
FinProceso
Algoritmo ( diagrama de flujo )
Proceso Intercambio
A,B
AUX <- A
A <- B
B <- AUX
A,B
Fin Proceso
Página 24/44
Prueba de escritorio o seguimiento de algoritmos

En las etapas de resolución de problemas se propuso la etapa de Verificación luego de escribir
la codificación (algoritmo). Probar un algoritmo es ejecutar cada una de las acciones incluidas
en él; pero cómo efectuar una prueba en un algoritmo escrito en pseudocódigo o mediante un
diagrama de flujo ?.
La prueba de escritorio o seguimiento de un algoritmo puede efectuarse de la siguiente
manera:
a) Proponga un conjunto de datos. Estos datos deben coincidir en cantidad y tipo con
las variables que aparecen en las acciones de lectura.
b) Construya una tabla y coloque --encabezando cada columna de la tabla-- cada
una de las variables que aparezcan en el algoritmo.
c) Escriba SALIDA en el encabezado de la ultima columna de la tabla. Aquí se
anotarán los resultados que produzca el algoritmo como consecuencia de la acción de
Escribir .
d) Comience a ejecutar las acciones del algoritmo. Cuando encuentre una
asignación de una variable coloque el valor o dato a asignar en la columna
correspondiente a esa variable.
e) Si lee una variable, tome el dato de prueba propuesto para esa variable y
colóquelo en la columna de esa variable.
f) Si vuelve a asignar o a leer una variable ya creada, continúe anotando en la
columna correspondiente.
g) Al terminar de ejecutar las acciones, los resultados o salida del algoritmo deben
aparecer en la columna de SALIDA.
Ejemplo
El siguiente algoritmo calcula el promedio de 3 números utilizando una sola variable para leer
los datos de entrada.
Proceso Promediar
1 Sum  0;
2 Leer X;
3 Sum  Sum+X;
4 Leer X;
5 Sum  Sum+X;
6 Leer X;
7 Sum  Sum+X;
8 Prom  Sum/3;
9 Escribir ‘Promedio=’,Prom;
FinProceso
Se realizará la prueba o seguimiento para los datos 15, 40 y 35.
Página 25/44
Cada acción del algoritmo se halla numerada para poder seguir en detalle la modificación de
cada
Sum x Prom Salida
variable. 1 0
2 15
Cada fila de la tabla se 3 15
corresponde con una acción 4 40
5 55
algorítmica. La tabla con las 6 35
variables sería la indicada a 7 90
8 30
la derecha 9 Promedio= 30
Obsérvese en la fila 1, se ha asignado 0 a la variable sum. En la fila 2 la acción es Leer X y

como el primer dato propuesto para la prueba es 15, se coloca 15 en la columna de la x. En el
paso 3 se debe sumar sum+x, para lo cual se observa en la tabla que el valor actual de sum
es cero y el de x es 15 con lo cual la operación arroja 15; luego, se asigna ese resultado a
sum. Es decir que en el paso 3 la variable sum cambió tomando un nuevo valor (15) y
perdiendo el anterior(0).
Así sucesivamente hasta llegar a la acción de salida en el paso 9, donde se refleja el resultado
de dicha acción en la última columna de la derecha de la tabla.
Síntesis
1. Para plantear algoritmos computacionales y dar solución a problemas diversos se
requiere de un lenguaje algorítmico formal. Se empleará un pseudolenguaje de estructura
y sintaxis similar al de los lenguajes de programación de computadoras: pseudocódigo.
2. Esa formalización es necesaria para utilizar -más tarde- lenguajes de programación y
construir programas que una computadora pueda interpretar.
3. Para codificar un algoritmo computacional empleando pseudocódigo se debe
comenzar con la palabra Proceso <Nombre>. A continuación se plantean las acciones
que conforman el algoritmo y se finaliza con la palabra FinProceso.
4. Los elementos del pseudocódigo presentes en un algoritmo son las constantes,
variables, identificadores, expresiones y primitivas del lenguaje.
5. Las variables son lugares de memoria que permiten almacenar información. Se las
suele identificar con nombres (identificadores). Una de las formas de colocar un dato en
una variable es a través de la asignación. Otra forma es con la acción de lectura. Por
ejemplo:
X<-4.5; Leer z;
6. La información que maneja un algoritmo puede ser de naturaleza diferente, por ello se
definen 3 tipos de datos: numérico, caracter y lógico. Para cada tipo se plantean
operaciones diferentes y no se pueden mezclar en una misma expresión datos de distinto
tipo.
7. Dentro del tipo numérico se pueden emplear los operadores algebraicos de la
matemática básica y se dispone de una serie de funciones predefinidas similares a las
que Ud. puede hallar en una calculadora científica: SEN, COS, TRUNC, LN, etc.
8. Las expresiones permiten combinar variables, constantes y operadores para realizar
cálculos y comparaciones necesarios para resolver diversos casos.
Página 26/44
9. El tipo lógico tiene 2 constantes: VERDADERO y FALSO. En una expresión lógica se

pueden usar operadores relacionales y operadores lógicos.
10. El tipo caracter se basa en el conjunto de caracteres del código ASCII. Cada caracter
tiene un número de orden y gracias a ese orden es posible establecer relaciones de
orden: menor que, igual que, mayor que.
11. Las acciones primitivas son órdenes perfectamente definidas y preestablecidas para
que el ejecutante (la computadora) las interprete y las lleve a cabo.
12. Las acciones primitivas de estructura secuencial, se denominan así porque se
ejecutan una tras otra secuencialmente. Son ellas: la lectura o ingreso de datos, la
asignación, la escritura o salida de información.
13. Estas acciones se identifican unívocamente a través de palabras claves. Estas
palabras son reservadas y no pueden emplearse como identificadores de otros elementos
del algoritmo.
14. Los algoritmos computacionales también pueden representarse gráficamente a través
de diagramas de flujo. En estos diagramas los bloques o formas gráficas representan
acciones. El diseño en 2 dimensiones permite seguir con más claridad la lógica
propuesta.
15. Es posible probar algoritmos mediante un seguimiento del mismo. Esto es, proponer
una lista de datos que coincida con la cantidad y tipo de variables a leer. Luego ejecute
cada acción y anote en una tabla de variables como estas se van modificando. Cada
acción de escribir con el estado actual de las variables me permite determinar la salida
del algoritmo.
16. La documentación interna de algoritmos puede hacerse en pseudocódigo a través de
la doble barra (//). Utilice estos comentarios para describir la lógica aplicada a ciertas
acciones, o para recordar por qué efectuó cierto cálculo, etc. Estos comentarios son
útiles a la hora depurar (corregir) el código o interpretar la lógica del algoritmo más
ágilmente.
Por último: Los conceptos tratados hasta aquí, contribuyen a formalizar la metodología del
diseño de algoritmos computacionales a través de ciertas reglas formales, eliminando acciones
ambiguas o carentes de precisión. Esto no quiere decir, que planteado un problema, el
algoritmo que lo resuelva responda a una metodología única. Al contrario, el diseño de los
algoritmos requiere una gran dosis de creatividad, y es común hallar varios caminos para la
obtención de un resultado. Solo se trata de establecer pautas claras y precisas para que el
ejecutante (luego, la computadora) las interprete y pueda procesar la secuencia de acciones
que conforman un algoritmo computacional.
Página 27/44
Estructuras de control
Introducción
La formalización algorítmica que se comenzó a desarrollar en el tema anterior, ha permitido
resolver algunos problemas sencillos empleando algoritmos computacionales.
El objetivo de este tema es desarrollar nuevas herramientas algorítmicas para resolver

problemas más complejos, mediante el diseño de algoritmos estructurados. Esto sentará las
bases para facilitar más adelante el desarrollo de programas en un lenguaje estructurado.
En nuestros primeros diseños de algoritmos sólo se utilizaron tres acciones primitivas

fundamentales: lectura, asignación y escritura. Estos algoritmos fueron resueltos en base a una
estructura secuencial de acciones: los pasos o acciones indicados se ejecutan uno tras otro, a
medida que van apareciendo; es decir, secuencialmente.
Pero en el diseño de algoritmos, generalmente es necesario modificar el orden secuencial de

ejecución del conjunto de acciones. El diseño estructurado de algoritmos brinda recursos para
resolver este tipo de situaciones.
Teorema Fundamental de la Programación Estructurada
Baum y Jacopini demostraron que: "Todo problema computacional --

sin importar su complejidad-- puede resolverse empleando solo tres
estructuras básicas de control. Estas son: una de tipo SECUENCIAL,
otra de tipo CONDICIONAL y una de tipo REPETITIVO".
Cada una de esas estructuras conforma un segmento algorítmico perfectamente identificable

de acceso y salida únicos.
Un algoritmo estructurado está conformado por

segmentos de código. Cada uno de estos segmentos tiene un único punto
de entrada y un
único punto de salida.
Los algoritmos así diseñados son más legibles, y permiten seguir más fácilmente su lógica,
ayudando a la detección de errores, modificación y mantenimiento.
De acuerdo a lo mencionado, las acciones algorítmicas se encuadran en alguna de las
estructuras básicas de control siguientes:
 Secuenciales
 Condicionales
 Repetitivas
Página 28/44
Se analizarán -a continuación- cada una de ellas.
Estructura Básicas de Control

Estructura Secuencial
Las acciones correspondientes a esta estructura se van ejecutando en el orden en que
aparecen, es decir secuencialmente. Esta estructura puede representarse esquemáticamente:
acción A
acción B
acción C
Por convención, tales acciones al escribirlas en pseudocódigo deben ser finalizadas con el
signo de puntuación " ; " punto y coma.
Estructura Condicional Si-Entonces

Esta estructura implica una toma de decisión en el algoritmo, donde el ejecutante (la
computadora) puede seguir un camino u otro, según el valor de verdad de una expresión
lógica.
El esquema representativo de esta estructura es el siguiente:
falso verdadero
< exp. lógica >
B A
Donde <exp. lógica> es cualquier proposición que arroje un resultado lógico: Verdadero o
Falso.
La presencia de esta estructura en un algoritmo le indica al ejecutante que:
 debe evaluar la expresión lógica planteada.
 si es verdadera, debe ejecutar las acciones indicadas en A.
Luego ir al fin de la estructura.
Página 29/44
 si es falsa, resolver el bloque B. Luego ir al fin de la

estructura.
En el diagrama señalado, tanto el bloque A, como el B, pueden representar acciones

primitivas elementales o alguna otra estructura de control.
Nótese que esta estructura condicional tiene un solo punto de entrada y un único punto de
salida representados por un pequeño círculo con una E y una S respectivamente.
En pseudocódigo se expresará esta estructura de la manera siguiente:
Si <exp. lógica>
entonces A
sino B
FinSi
Donde las palabras claves Si y FinSi representan respectivamente la entrada y el fin de la

estructura.
Aquí también, si la expresión lógica arroja Verdadero, el ejecutante realiza A y luego va a
FinSi; si la expresión lógica arroja Falso realiza B y pasa a FinSi.
Ejemplo:
Problema: Determinar el valor de la función  3 ln( x)  5 x si x > 2

arbitraria y=f(x) que se indica a la derecha Y  
para un valor de la variable x que se lee  2x  1 si x <= 2
como dato.
Solución empleando pseudocódigo:
Proceso FArbitraria
Leer X;
Si X > 2
Entonces
y3*ln(x)-5*x;
sino
y2*x-1;
FinSi
Escribir 'Valor de la función: y=', y;
Fin Proceso
Página 30/44
Solución empleando diagrama de flujo:
Inicio
falso verdad
X > 2
y 2x - 1 y 3Ln(x) - 5x
'Valor de la Función: y = ' , y
Fin
Obsérvese que la visualización bidimensional que ofrece el diagrama permite una mejor
legibilidad de la lógica del algoritmo respecto del pseudocódigo.
En una estructura condicional, la salida por Verdadero, siempre tendrá al menos una acción
para ejecutar; pero es posible que no haya acciones en la salida por Falso de la expresión
lógica. Esta variante de la estructura condicional se expresará en pseudocódigo de la manera
siguiente:
Si <exp.lógica>
entonces A
FinSi
Y en un diagrama de flujo:
falso verdad
< exp. lógica >
Es recomendable respetar la forma gráfica del esquema, tal como se propone. Esto es porque
la forma de diamante o rombo se empleará para otras estructuras, y si se altera el esquema,
puede resultar confuso el seguimiento de su lógica.
Página 31/44
Estructura Repetitiva Mientras-Hacer

Esta estructura permite ejecutar una acción o grupo de acciones en forma reiterada, cierto
número de veces, mientras se cumpla una condición. El esquema gráfico que se empleará en
los diagramas de flujo será el siguiente:
falso
< exp. lógica >
verdad
R
D
El pequeño círculo con la E indica la entrada o ingreso a la estructura, donde debe evaluarse
una expresión lógica. Si el valor obtenido es Verdadero el control de ejecución permanece
dentro de la estructura y se ejecutan las acciones allí encerradas; en el ejemplo propuesto: P,
Q, y R .
El círculo con la D señala el punto delimitador del Mientras e indica que se debe volver a
evaluar la expresión lógica del comienzo.
El valor de verdad que se obtenga determinará si el control de ejecución permanece o sale del
esquema.
La sintaxis correspondiente en pseudocódigo es:
Mientras <exp. lógica> Hacer

acción A
acción B
acción C
FinMientras
El punto D del diagrama se corresponde con el delimitador FinMientras. En ese lugar se indica
al ejecutante que debe volver a observar el valor de verdad de la proposición lógica. Si esta
arroja verdadero se vuelven a ejecutar las acciones A, B, C; si arroja falso, el control escapa
de la estructura para pasar a ejecutar la próxima acción después del FinMientras.
Como en la estructura condicional, aquí también se tiene un único punto de entrada y un único
punto de salida.
Dos características particulares de la estructura repetitiva Mientras:
Página 32/44
 Es posible que en un algoritmo las acciones encerradas en la estructura

nunca lleguen a ejecutarse, si la expresión lógica arroja un falso en la
primer evaluación.
 En el grupo de acciones que abarca la estructura es necesaria la

presencia de cierta acción, que permita alguna vez, modificar el valor de
verdad de la expresión lógica que controla el Mientras. De lo contrario
se estaría en presencia de un bucle infinito.
Al disponer de un proceso repetitivo o iterativo en un algoritmo, se pueden plantear soluciones

a problemas más complejos o que involucren una gran cantidad de datos. Se verá que los
problemas y sus correspondientes algoritmos no difieren en mucho de lo que UD. venía
haciendo hasta ahora; solo se incorpora a la secuencia de acciones una estructura que las itere
(repita). De este modo se puede lograr la repetición sistemática de un proceso, lo que implica
importantes ventajas desde el punto de vista computacional debido a la velocidad con que
pueden operar las computadoras.
¿Qué ocurre ahora con la lectura de numerosos datos . Aprovechando el proceso iterativo se
puede leer un dato o grupo de datos, realizar sobre ellos el proceso correspondiente, luego
repetir la lectura para el segundo dato o grupo de datos, procesarlo y así sucesivamente. Para
aclarar esto obsérvese el ejemplo siguiente.
Problema: Leer una serie de datos numéricos correspondientes a las edades de 90

personas. Obtener e informar el valor de la suma y la media (promedio) de dicho
conjunto de datos.
Solución empleando Diagrama de Flujo
In ic io
C o nteo  0
S um a  0
fa ls o
C o nte o <
90
ve r da d
x
C o n te o C o nteo + 1
S um a  S um a + x
M e dia S um a /C o nte o
'S uma = ' , S uma
' M e d ia = ' , M e dia
Fin
Página 33/44
Solución en pseudocódigo
Proceso Media
Conteo  0;
Suma  0;
Mientras Conteo < 90 Hacer
Leer X;
Conteo  Conteo + 1;
Suma  Suma + X;
FinMientras
Media  Suma/Conteo;
Escribir 'Suma=', Suma;
Escribir 'Media=', Media;
FinProceso
Nótese que la acción Conteo  Conteo +1 permite controlar la estructura al

incrementar en una unidad la variable Conteo. En cierto momento Conteo tomará
el valor 90 y el control de ejecución escapará del Mientras para pasar a la acción
que permite calcular la media.
Los datos se ingresan en la variable x de a uno por vez ( 90 veces ).
Estructuras de Control Adicionales

De acuerdo al Teorema Fundamental de la Programación Estructurada enunciado por Baum y
Jacopini serían suficientes las estructuras hasta aquí planteadas para resolver cualquier
problema computacional. Pero en diversas situaciones --limitados por tan pocas herramientas--
es posible encontrar diseños de algoritmos algo intrincados, engorrosos, o faltos de claridad.
Por tal motivo, se estudiará el uso de estructuras adicionales, que no son sino variantes de las
ya vistas y pueden ayudar a clarificar el diseño de ciertas soluciones.
Estructura Condicional de Selección Múltiple

En varias situaciones se presentará el caso de que la decisión a tomar para bifurcar el flujo o
control de ejecución en un algoritmo no se basa en un proposición lógica única con dos
posibles alternativas; sino, que los caminos posibles a seguir serán: 3, 4, ..,10 o más.
Tal situación puede resolverse con la Estructura Condicional Si-Entonces.
Se analizará en un ejemplo la resolución de un caso como el descrito.
Ejemplo
Página 34/44
Un club deportivo posee N socios. Tiene 5 categorías de asociados: 1, 2, 3, 4 y 5; que

corresponden respectivamente a vitalicios, mayores, juveniles cadetes e infantiles. A cada
categoría le corresponde abonar una cuota mensual diferente, a excepción de las categorías
cadetes e infantiles que pagan igual monto.
Además, los cadetes y juveniles --por este mes-- tienen un descuento del 25%, y el resto de las
categorías un 10%. El club desea conocer el monto correspondiente a la recaudación mensual
por el abono de cuotas de asociados, suponiendo que abona la totalidad de los mismos.
Datos generales del problema: N: número de asociados.

C1, C2, C3, C4: monto de cada cuota.
Y por cada socio: Cat: categoría del socio.
Solución:
Proceso Club
C 0 ; Suma 0 ;
Leer N, C1, C2, C3, C4 ;
Mientras C<N Hacer
Leer Cat ;
C C+1 ;
Si Cat=1
Entonces Cuota  C1*0.90;
Sino Si Cat=2
Sino Si Cat=3
Entonces Cuota  C3*0.75 ;
Sino Si Cat=4
Sino Cuota  C4*0.90;
FinSi
FinSi
FinSi
FinSi
Suma  Suma + Cuota ;
FinMientras
Escribir 'Recaudación del mes:', Suma ;
FinProceso
Página 35/44
Como se puede observar en la solución planteada para el ejemplo, el empleo de la estructura

condicional Si-Entonces resuelve el caso; pero a pesar de la sencillez del problema, el
seguimiento de la lógica es confuso.
Para tal situación se propone una estructura que contempla la posibilidad de establecer una
selección entre varias posibilidades clarificado el algoritmo. Esta estructura se denomina
Estructura Condicional de Selección Múltiple, y se trata de una generalización de la estructura
condicional.
En ella, en lugar de evaluar una condición o expresión lógica, se coteja el valor de cierta
variable, llamada variable de control de la estructura, con una lista de valores posibles. El valor
determinará cual es la próxima acción a ejecutar.
Según V Hacer
1: A:
2: B;
3,4: C;
.
.
n: Q;
FinSegún
Donde V es la variable de control, que debe ser de tipo numérico y además entera positiva sin
incluir el cero. Al encontrar esta estructura, el ejecutante (la computadora) realiza lo siguiente:
 Observa el valor de la variable V.
 Buscar en la lista de valores propuestos el valor que coincida con el de V.
 Si encuentra dicho valor, ejecutar las acciones indicadas para esa opción.
Luego, ir al fin de la estructura (FinSegún).
 Si el valor asignado a la variable, no coincide con ningún valor de la lista
propuesta, salta al FinSegún sin ejecutar acciones.
Opcionalmente, pueden plantearse acciones para el caso de que la variable de control V no

coincida con ningún valor de la lista. La sintaxis alternativa es la siguiente:
Según V Hacer
1: A:
2: B;
3,4: C;
.
.
n: Q;
De Otro Modo
Página 36/44
R;
FinSegún
Si para más de un valor, se debe realizar la misma acción (o grupo de acciones), tales valores
pueden agruparse en la misma línea separados por coma. Es el caso de los valores 3 y 4
indicados más arriba al describir la sintaxis.
Para esos dos valores, debe realizarse la misma acción (o grupo de acciones) que se identificó
con C.
Nota: A, B, C,...Q, y R pueden representar desde una acción elemental hasta un grupo de
acciones o estructuras.
El esquema que se empleará en un diagrama de flujo para la estructura Según es el siguiente:
v
....... De Otro
1 2 3,4 n Modo
C Q
A
R
B
Al igual que la estructura condicional, se tiene aquí, un único punto de entrada y un único punto
de salida que en el gráfico se indican con los pequeños círculos que encierran una E y una S.
Obsérvese en el mismo caso del club que se usó como ejemplo introductorio a este tema,
cómo aplicar la estructura de selección múltiple.
Ejemplo:
Un club deportivo posee N socios. Tiene 5 categorías de asociados: 1, 2, 3, 4 y 5; que
corresponden respectivamente a vitalicios, mayores, juveniles cadetes e infantiles. A cada
categoría le corresponde abonar una cuota mensual diferente, a excepción de las
categorías cadetes e infantiles que pagan igual monto.
Además, los cadetes y juveniles --por este mes-- tienen un descuento del 25%, y el resto
de las categorías un 10%. El club desea conocer el monto correspondiente a la
recaudación mensual por el abono de cuotas de asociados, suponiendo que abona la
totalidad de los mismos.1
Datos generales del problema: N: número de asociados.

C1, C2, C3, C4: monto de cada cuota.
Página 37/44
Y por cada socio: Cat: categoría de un socio.
Solución
Proceso Club
C 0 ; Suma  0 ;
Leer N, C1, C2, C3, C4 ;
Mientras C < N Hacer
Leer Cat ;
C C + 1 ;
Según Cat Hacer
1: Cuota  C1 * 0.90 ;
2:Cuota  C2 * 0.90 ;
3:Cuota  C3 * 0.75 ;
4:Cuota  C4 * 0.75 ;
5:Cuota  C4 * 0.90 ;
FinSegún
Suma  Suma + Cuota ;
FinMientras
Escribir 'Recaudación del mes:', Suma;
FinProceso
Compare ambas soluciones del problema, con y sin la estructura de selección múltiple, y podrá
observar la diferente legibilidad en favor del último ejemplo donde se ha empleado la estructura
Según.
Estructura Iterativa Repetir-Hasta que

Esta herramienta algorítmica adicional, tiene cierta similitud con el Mientras-Hacer, ya que se
debe evaluar cierta proposición lógica, cuyo resultado permite continuar o escapar del bucle
iterativo. Su esquema gráfico se indica abajo:
Página 38/44
< exp. lógica >

falso
D verdad
En presencia de esta estructura, el ejecutante del algoritmo, ingresa a la estructura, resuelve

las acciones indicadas en los bloques P, Q, y R; entonces evalúa la expresión lógica: si esta
es falsa, vuelve a repetir las acciones. Así sucesivamente Hasta que la expresión lógica arroje
un resultado verdadero.
Su sintaxis para el pseudocódigo es:
Repetir
acción P ;
acción Q ;
acción R ;
Hasta que <exp. lógica>
Al igual que el Mientras, la estructura Repetir posee algunas características particulares:
 Si la expresión lógica arroja un verdadero en la primer evaluación, las

acciones abarcadas por la estructura ya habrán sido ejecutadas. Por
tanto --siempre-- las acciones de esta estructura serán realizadas al
menos una vez.
 En el grupo de acciones que abarca la estructura es necesaria la

presencia de cierta acción, que permita alguna vez, modificar el valor de
verdad de la expresión lógica que controla el Repetir. De lo contrario se
estaría en presencia de un bucle infinito.
Observación: en las dos estructuras iterativas o de repetición estudiadas, se puede notar que
no es necesario conocer el número de iteraciones a realizar. Es común hallar problemas donde
la proposición lógica que controla a ambas estructuras, sea dependiente de alguno de los datos
de entrada del algoritmo.
Estructuras de control anidadas

En el diseño de algoritmos, es usual el empleo de estructuras lógicas de control en situaciones
más complejas, las cuales se resuelven combinando las estructuras básicas y adicionales que
se desarrollaron en esta unidad. Obsérvense algunos casos:
Página 39/44
CASO 1
Aquí, se presenta una
estructura condicional con una
F V acción simple en la salida por
Decision
VERDAD. Por FALSO, tiene
otra estructura condicional
Acción
anidada
F V
Decision Ejemplo: observe la solución
propuesta para el problema del
Club que se usó para introducir
Acción
Acción el tema de la estructura Según
Caso 2.
El diagrama plantea
F una estructura iterativa
Mientras
MIENTRAS, la cual
encierra una estructura
V condicional.
Acción
F V
Decision
.
Acción Acción
Caso 3.
Página 40/44
F
Decisión En este caso, se tiene
un REPETIR anidado
dentro de la salida por
VERDADERO de la
Acción
Acción
estructura condicional.
Acción
F
Hasta que
Caso 4.
Aquí una estructura

Mientras encierra acciones
F de estructura secuencial y
Mientras además una estructura
iterativa Repetir-Hasta que.
V
Acción
Acción
F
Hasta que
V
Acción
IMPORTANTE:. en todos los

casos, observe que cada estructura encerrada o anidada en otra, tiene su punto de entrada y
su punto de salida, dentro de la estructura anidante.



Síntesis
Página 41/44

17. Las estructuras de control permiten resolver algorítmicamente problemas más
complejos. Con ellas es posible tomar decisiones, iterar o repetir grupos de acciones.
18. Cada estructura de control tiene un único punto de entrada y un único punto de salida.
Esto es propio del modelo o paradigma de la programación estructurada.
19. La estructura condicional Si-Entonces permite tomar un camino u otro en la secuencia
de ejecución, en base al valor de verdad de una proposición lógica.
20. La estructura iterativa Mientras-Hacer permite evaluar una expresión lógica al inicio y
si su valor de verdad arroja verdadero se ejecutan las acciones incluidas en la estructura;
luego se vuelve a evaluar la expresión lógica y así sucesivamente. Las acciones incluidas
en esta estructura se podrán ejecutar 0 o más veces.
21. La estructura de selección múltiple Según-Hacer permite ejecutar una o más acciones
selectivamente en base al valor de una variable de control que es evaluada al inicio.
22. La estructura iterativa Repetir-Hasta Que actúa similarmente a la estructura Mientras-
Hacer solo que la expresión lógica se evalúa al final; si esta arroja verdadero se abandona
la estructura, y se continúa iterando en caso de arrojar falso.
23. A medida que lo problemas se hacen más complejos es usual tener que combinar
estructuras encerrando o anidando unas dentro de otras. En estos casos recordar que
cada estructura anidada debe estar completamente incluida dentro de la estructura exterior
o anidante.
ANEXO: Arreglos
Introducción:
Hasta ahora hemos empleado variables simples. Su uso estaba limitado a una única
posición de memoria en la cual podíamos alojar un dato individual. En ciertos casos es
conveniente almacenar conjuntos de datos que guardan cierta relación entre sí; por ello
requerimos el uso de estructuras de datos que permitan una mejor organización y tratamiento
de los datos.
Una estructura que nos permite un grado de organización mayor es el arreglo.
Un arreglo es una estructura que permite representar un conjunto de datos del mismo
tipo y cuyos elementos se referencian por su posición dentro de la estructura.
Características de los Arreglos:

Al ser una estructura de datos, significa que se trata de un conjunto de datos o valores,
donde cada elemento individual se almacena en una posición de memoria diferente.
En el caso particular de un arreglo, sus componentes se almacenan en posiciones de
memoria contiguas o consecutivas.
Página 42/44
En resumen:
Todo arreglo posee un nombre genérico único, que debe respetar las reglas sintácticas de los
identificadores de variables, y cada elemento del conjunto se identifica por este nombre más la
posición que ocupa en la estructura.
Sus componentes o elementos son homogéneos (del mismo tipo).
Los elementos se relacionan lógicamente entre sí. Representan distintos valores de un mismo
ente o clase. Por ejemplo los datos de un arreglo pueden representar los legajos de los
alumnos, los caudales diarios de una sección de un río, los nombres de los socios de un club,
las notas de un conjunto de estudiantes, etc.
El arreglo tiene una dimensión declarada en el algoritmo, que establece la máxima cantidad de
componentes que puede referenciar.
Los arreglos pueden clasificarse de acuerdo a la organización de sus elementos y a la

forma de referenciar las posiciones de sus componentes. Así podemos distinguir arreglos
unidimensionales o lineales, bidimensionales o tablas y multidimensionales.
Arreglos Unidimensionales:
Es unidimensionales cuando la referencia a uno de sus componentes se realiza a través
de un único valor llamado índice, que determina la posición del elemento dentro del arreglo.
Estos arreglos también son conocidos como vectores.
Definir un arreglo:
Dimensión A[5]; //esto indica un arreglo llamado “A” de 5 elementos, empezando
//desde el 1 hasta 5 elemento.
Modo de Uso: Cada elemento del arreglo lineal se indica con el nombre del vector seguido del
índice entre corchetes. Ej. A[1] representa el quinto elemento del vector A, pudiéndoselo utilizar
dentro de expresiones o asignándole un elemento en esta posición como una variable normal.
Ej. A[3] <-- 51;
Gráficamente:
A[1] A[2] A[3] A[4] A[5]

25 128 51 32 4
Arreglos Bidimensionales:
Si la posición de un elemento en un arreglo debe ser precisada a través de 2 índices
decimos que el arreglos es bidimensional. También se los conoce como tablas o matrices.
En una tabla, el primer elemento nos da la posición de la fila y el segundo de la
columna. Por ejemplo:
A[1,1] A[1,2] A[1,3] A[1,4] A[1,5]

A[2,1] A[2,2] A[2,3] A[2,4] A[2,5]
A[3,1] A[3,2] A[3,3] A[3,4] A[3,5]
Página 43/44
Arreglos Multidimensionales:
Es posible proponer estructuras de tipo arreglo, donde las posiciones de cada elemento
deban ser referenciadas por 3 o más índices.
Por ejemplo: si deseamos manejar en un algoritmo la lista de alumnos de una escuela
de enseñanza media que posee 5 años, 6 divisiones por año y 30 alumnos por curso o división,
deberemos definir un arreglo tridimensional:
Dimensión A[5,6,30]
Y para referenciar al alumno Nro. 17 que cursa en 2do año, división 4: A[2,4,17]
Página 44/44

Programacion Teoria

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Programacion Teoria

Загружено:

Авторское право:

Доступные форматы

FUNDAMENTOS DE INFORMÁTICA

Etapas en la resolución de problemas con computadora

1. análisis del problema

2. Diseño de una solución

Del detalle de las etapas anteriores puede observarse que:

Flexibilidad: permite abordar la solución de problemas similares con pequeños cambios.

Obsérvese que en la definición y en las características no se hace mención alguna de

Precondición es la información que se conoce como verdadera antes de comenzar el algoritmo.

Problema : Indique la manera de salar una masa.

Elementos que componen un algoritmo

 Elegir una lámpara nueva de la misma potencia que la anterior.

Ejemplo : Escriba un algoritmo que permita a un robot subir 8 escalones

Analice el siguiente ejemplo:

Los aspectos más importantes son:

Se analizan a continuación algunos algoritmos que tienen repeticiones.

Ejemplo : Escriba un algoritmo que permita a un robot subir 8 escalones.

Importancia de la indentación en las estructuras de control

La tercera etapa para la resolución de problemas es la Especificación de Algoritmos y en ella se

Esta unidad propone describir la formalización necesaria para el desarrollo de Algoritmos

En el ejemplo que se propone a continuación se desarrolla un algoritmo completo de acuerdo a

Análisis del Problema:

Descripción de los elementos presentes en el ejemplo

La forma general de un algoritmo escrito en pseudocódigo es la siguiente:

PROCESO nombre del proceso

Elementos de un algoritmo computacional

123 'López' Falso 3.1459

se observa que 2 e ‘Hipotenusa=’ constituyen constantes. A, B H son variables.

Esta sintaxis y sus restricciones no representan inconvenientes para proponer nombres de

venta x12 resultado SUMA2 M3M

2+a-x*5 45 A < B TRUNC(R) + 1

Ejemplos de constantes numéricas:

14 -12500 +1.9452 -567.91 1.3E+2 -0.94E-3

Es de mencionar que ciertos lenguajes de programación no disponen de todos los operadores

Ejemplos de expresiones numéricas

Constantes Tipo Caracter

Ejemplos de constantes tipo carácter

'Luis Rodríguez' 'Z' 'Resultado='

Importante: En este tipo de información: el conjunto de caracteres ASCII, es un conjunto

El código ASCII se ha convertido en un standard mundial que permite compatibilizar la

32 '' 48 '0' 64 '@' 80 'P' 96 '`' 112 'p'

41 ')' 57 '9' 73 'I' 89 'Y' 105 'i' 121 'y'

La letra 'a' es mayor que la letra 'B'.

El caracter '5' es menor que la letra 'A'.

La cadena de caracteres 'Mario' es menor que ‘Roberto’.

Variables Tipo Caracter

Expresiones Tipo Caracter

Ejemplos de expresiones lógicas relacionales

23<45 A+2>=100 'a'<>LETRA

'ANA'<'LUIS' (2+B) >=Trunc(2+B) 7>'M'

Las expresiones lógicas simples mostradas en el ejemplo se conocen como expresiones

La algorítmica computacional, permite también formar expresiones lógicas mas complejas a

Se observa entonces el valor de verdad de las expresiones lógicas propuestas en el ejemplo

('A'<'a')  (12>19) VERDADERO

('MARIA'<'MARTA')  (1>2) FALSO

Primitivas de Estructura Secuencial

Primitivas de Estructura Condicional

En la próxima unidad se desarrollarán las estructuras algorítmicas de control que implican el

Acciones Primitivas de Estructura Secuencial

Si V es una variable numérica y E cualquier expresión de tipo numérica la asignación es

Ejemplos de Asignaciones Numéricas

A  43; ( A toma el valor 43 )

X  A; ( X toma el valor contenido en A )

NUM  3*X/A+2; ( NUM toma el valor del resultado de