Índice

2. Estructuras de programación.............................................................................2
2.1. Estructura de secuencia...............................................................................3
2.2 Estructura de decisión..................................................................................4
2.2.1 Decisión simple..........................................................................................5
2.2.2 Decisión múltiple:......................................................................................7
2.3. Estructura de repetición............................................................................10
2.3.1 Ciclo exacto:..............................................................................................10
2.3.2 Ciclo inexacto:..........................................................................................13
Resumen Estructuras de programación..........................................................17
Conceptos básicos de Programación

2. Estructuras de programación

Definimos a un programa de computadora como un conjunto ordenado de

instrucciones que le indican al procesador lo que debe hacer. Cuando
ejecutamos un programa éste se carga en la memoria principal de la
computadora: tanto las instrucciones como los datos del programa residen
allí. Ahora bien, ¿cómo sabe el procesador qué es lo que debe hacer?. En
nuestra materia no nos interesa conocer el detalle de este proceso: basta
saber que, conocida la instrucción inicial, el procesador tiene un mecanismo
que le permite saber en que parte de la memoria está la instrucción siguiente,
y las ejecuta una a una hasta que el programa termine. También sabe como
responder ante cada instrucción: la decodifica y manipula los componentes
necesarios para responder a la acción que la instrucción determina.

Las primeras computadoras se debían programar indicándole directamente al

procesador que es lo que debía hacer. Las instrucciones eran muy elementales
(de bajo nivel), por lo que construir un programa era una tarea muy costosa. El
desarrollo posterior de los lenguajes de programación permitió crear
programas en los que las instrucciones son más flexibles y potentes (una sola
instrucción del lenguaje puede contener múltiples instrucciones de
procesador), ya que están basados en máquinas abstractas, que facilitan la
comprensión por parte de las personas. Para que el procesador entienda estas
instrucciones se necesita un traductor (el compilador) para convertir el
programa al lenguaje de la máquina. A este tipo de lenguajes se los denomina
de alto nivel (más cercano al lenguaje que utilizamos nosotros).

En los lenguajes de alto nivel se programa con las instrucciones que entiende
la máquina abstracta que proporciona el lenguaje. Por ejemplo, en nuestros
programas utilizaremos una instrucción para ingresar datos desde el teclado, y
almacenar esos datos en alguna parte de la memoria, haciendo abstracción de
todos los mecanismos involucrados en esa tarea. No nos interesan esos
detalles, ya que los resuelve el traductor.

De los estudios y las experiencias derivadas del desarrollo de los lenguajes de

programación se llegó a la formulación del Teorema Fundamental de la
Programación Estructurada, que establece que todo problema computacional
– sin importar la complejidad de éste- puede resolverse utilizando las
siguientes estructuras de control:
- Estructura de secuencia.
- Estructura de decisión, o selección.
- Estructura de repetición o iteración.

Estas estructuras pueden combinarse entre si sin ningún tipo de restricción

para desarrollar cualquier programa. Veamos cada una de ellas.
2.1. Estructura de secuencia
La estructura secuencial establece el orden en el que se ejecutarán las
instrucciones. Todo programa es un conjunto ordenado de instrucciones. El
orden de ejecución está determinado por la ubicación de cada instrucción.

En el lenguaje de diagrama de flujo que utilizaremos cada instrucción está

contenida en un bloque, y cada bloque tiene una única entra y una única
salida. El orden o secuencia es la que resulta de leer el algoritmo desde su
inicio en la parte superior, hasta su fin en la parte inferior. La secuencia está
presente en todos los programas, independientemente que se utilicen otras
estructuras. Veamos algunos ejemplos:

Ejemplo 1

Dados dos números que se ingresan por teclado, calcular e informar la suma

suma=a+b

suma

Ejemplo 2

Se dan como datos las longitudes de los dos catetos de un triángulo

rectángulo y se debe calcular e informar el área del triángulo.
 P

base

altura

superficie=base*altura /2

superficie

En ambos ejemplos cada uno de los bloques tienen una sola entrada y una
sola salida, y su distribución permite fácilmente entender el orden de
ejecución. Un diagrama como el que sigue no respeta la estructura de
secuencia

base altura

superficie =base*altura /2

superficie

ya que no permite determinar el orden de ejecución de las 2 primeras

instrucciones.

2.2 Estructura de decisión

La estructura de decisión permite que un programa elija entre 2 o más cursos
posibles de acción por si mismo. La elección del curso de acción está
determinada por la respuesta que el programa obtenga de la proposición
lógica contenida en la decisión.
Toda proposición lógica o condición al evaluarse puede tener como resultado
Verdadero (si la condición se cumple) o Falso (si la condición no se cumple).

Existen dos formas de implementar la estructura de decisión:

- Decisión simple: permite seleccionar uno de dos caminos posibles
- Decisión múltiple: permite elegir entre dos o más caminos de ejecución
posibles.

2.2.1 Decisión simple

La forma de representar la decisión simple en nuestros diagramas de flujo es
la siguiente

V Condición F
a evaluar

Acciones si Acciones si
verdadero falso

Dentro del rombo se incluye la proposición lógica que se va a evaluar. Si el

resultado es Verdadero, la ejecución del programa continuará por el lado
izquierdo, si es Falsa la ejecución continuará por la rama de la derecha. En
cualquiera de los casos, la acción por verdadero o falso puede ser no hacer
nada. Veamos algunos ejemplos

Ejemplo 1

Dados dos valores numéricos distintos determinar e informar el mayor de

ambos.

n1

n2

n1>n2

n1 n2

F
Ejemplo 2:
Construir un algoritmo que determine e informe si un número A es múltiplo
de otro B.

resto=a%b

resto= = 0

“Es múltiplo”

En el ejemplo 1 el programa contiene tanto acciones por el lado verdadero

como por el lado falso, porque el enunciado lo exige: pide que se informe el
número más grande.

Veamos como responde el algoritmo si le damos valores a n1 y n2.

Caso 1: n1= 8; n2=5

El programa al llegar a la decisión se pregunta lo siguiente:

SI n1>n2 entonces Mostrar n1
Si No Mostrar n2

Más precisamente podemos decir que el programa evalúa el valor de verdad

de la proposición lógica n1>n2. Y esto depende de los valores que contengan
n1 y n2.
Reemplazando la notación simbólica por números concretos tendremos:
8>5 VERDADERO
entonces el programa ejecutará las instrucciones contenidas en la rama
izquierda del diagrama, mostrando por pantalla el número 8. Las instrucciones
del lado falso se ignoran.

Caso 2: n1= 14; n2=20

La evaluación en este caso será

14>20 FALSO
entonces el programa ejecutará las instrucciones contenidas en la rama de la
derecha del diagrama, mostrando por pantalla el número 14. Las instrucciones
del lado verdadero se ignoran.

En los lenguajes de programación para la decisión simple se usa la palabra if

(si condicional del idioma inglés).

2.2.2 Decisión múltiple:

La forma de representar la decisión múltiple en nuestros diagramas de flujo es
la siguiente

Variable a analizar

Valor 1 Valor 2 Valor 3 default

Acciones si no es Valor1,
Acciones si Valor 1 Acciones si Valor 2 Acciones si Valor 3
ni Valor 2, ni Valor 3

La decisión múltiple permite que el programa elija uno entre varios (dos o
más) cursos probables de acción. El curso de acción que se seleccione
dependerá del valor que contenga la variable que se utilice como selectora.
La variable “selectora” se ubica en el triángulo superior del diagrama; luego se
compara el valor contenido por ésta con las constantes que se sitúan
inmediatamente después del triángulo superior (representadas
genéricamente como Valor 1, Valor 2, etc), ejecutándose las acciones que se
encuentren bajo el valor constante que coincida con el de la selectora. Si el
valor de la selectora no coincide con ninguno de los existentes, se ejecutarán
las instrucciones contenidas bajo la etiqueta default.

La forma general de la decisión múltiple es:

De acuerdo al valor de la variable selectora, hacer:

En caso que sea Valor 1: Acciones si Valor 1
En caso que sea Valor 2: Acciones si Valor 2
………………………….
………………………….
Sin coincidencias: Acciones por defecto.

Veamos algunos ejemplos:

Ejemplo 1:
Hacer un programa que informe si se presionó la tecla 1, 2, ó 3. Si no se
presionó ninguna de esas teclas informar “Número distinto de 1, 2, ó 3”.

1 2 3 default

“Se presionó la “Se presionó la “Se presionó la “Número distinto a 1,

tecla 1” tecla 2” tecla 3”
1” 2 ó3”

Ejemplo 2:
Hacer un programa para ingresar dos números, y luego realizar las acciones
que se detallan de acuerdo con las siguientes opciones:
- La suma de los dos números si se presiona la tecla 1 luego del ingreso
de los dos números.
- La resta del primero menos el segundo si se presiona la tecla 2 luego
del ingreso de los dos números.
- El producto de los dos números si se presiona la tecla 3 luego del
ingreso de los dos números.
 P

n1

n2

“Ingrese un 1 para sumar ,

un 2 para restar ,
o un 3 para el producto”

opc

opc

1 2 3 default

suma=n1+n2 resta=n1-n2 producto =n1*n2

“Opción incorrecta”
suma resta producto

En el primer ejemplo n es utilizada como selectora. Si el valor de n es 1, se

ejecutarán las acciones contenidas en el rectángulo que se ubica debajo del
valor 1. En este caso la única acción es la impresión por pantalla de un cartel;
lo mismo sucede para el caso que n contenga un 2 ó un 3. Si n contiene
cualquier valor distinto de 1, 2, ó 3, el programa seguirá la ejecución por
default.

En el segundo ejemplo la selectora es opc. De acuerdo al valor que se le de a

opc el programa ejecutará acciones distintas.

En los dos ejemplo se utilizaron 3 valores distintos para la variable selectora,

más la opción por defecto. Podrían haber sido 4, ó 5, o los necesarios para la
resolución de un problema. Tampoco es imprescindible que los valores sea
correlativos, ni que estén ordenados de manera creciente: podrían haber
tomado cualquier valor siempre y cuando éstos sean números enteros (más
adelante se verá que también pueden utilizarse caracteres).

Nótese que en la decisión múltiple no existen proposiciones lógicas explícitas,

como en la decisión simple. Su misma estructura determina que se compare
el valor de la variable selectora con las constantes de cada caso.
En el lenguaje de programación C/C++ para la decisión múltiple se usa la
palabra switch para la selectora, y case para cada una de las opciones.

2.3. Estructura de repetición

La estructura de repetición (o iteración) permite que una instrucción o un
conjunto de instrucciones se ejecuten de manera repetitiva, o en un ciclo.
También se suele denominar como bucle.

Es muy común que en los problemas a resolver se presenten situaciones

donde haya que actuar sobre un conjunto de datos de la misma manera, es
decir, que sea necesario realizar las mismas operaciones sobre ese conjunto.
Por ejemplo, si se quisiera saber cuántos alumnos del curso tienen más de 20
años, habría que evaluar la edad de cada alumno, y si es mayor que 20, ir
sumando 1 a un valor que inicialmente debería estar en 0. Por cada valor de
edad habría que repetir la comparación y en caso que corresponda sumar 1.
Idéntico tratamiento habría que darle al siguiente enunciado: dado un
conjunto de valores de temperatura informar cuántos de ellos fueron
inferiores a 0.

En cualquier caso, la cantidad de veces que las instrucciones se repetirán está

condicionada por el conocimiento o no de la cantidad de datos a analizar, lo
que da lugar a dos formas distintas de implementación práctica de la
estructura de repetición.

2.3.1 Ciclo exacto:

El ciclo exacto permite que un conjunto de instrucciones se repitan una
cantidad definida de veces. Esta cantidad debe ser conocida antes del inicio
del ciclo. Por ejemplo, el siguiente problema podría resolverse utilizando un
ciclo exacto:

Dadas las edades de los 40 alumnos de un curso, calcular e informar cuántos

de ellos son mayores a 20 años.

ya que de antemano sabemos que se van a ingresar 40 edades.

La forma de representar el ciclo exacto en nuestro lenguaje de diagrama de

flujo es la siguiente:
 Instrucción o conjunto de
i instrucciones
a ejecutar
i=1 i<=40 i++

Dentro del rectángulo que enmarca el ciclo exacto se colocan las instrucciones
que se quieren ejecutar de manera repetitiva. Dentro del círculo se establece
la cantidad de veces que las instrucciones se repetirán, de acuerdo a lo
siguiente:

Variable de control

i=1 i<=50 i++

Valor inicial de la
variable de control
Incremento de la
variable de control

Condición a
evaluar

Variable de control: controla la ejecución del ciclo. De acuerdo al valor que

tenga en cada momento, las instrucciones se volverán a ejecutar o no.

Valor inicial: se establece cuando el programa ingresa al ciclo por primera

vez.

Condición a evaluar: es una proposición lógica que generalmente involucra a

la variable de control. Si el valor de verdad de la proposición es verdadero, las
instrucciones contenidas volverán a ejecutarse; si es falso el ciclo se termina.

Incremento: por cada ciclo completo la variable de control incrementa su

valor.
Para el caso de la figura el funcionamiento sería:
- Al llegar el programa al ciclo exacto, a la variable de control i se le
asigna el valor 1.
- Luego se evalúa la condición, y como 1<=50 es verdadero, se
incrementa el valor de la variable en 1, y se ejecutan las instrucciones
contenidas dentro del ciclo
- Una vez finalizada la ejecución de las instrucciones, se vuelve a evaluar
la condición. Como i ahora vale 2, la condición 2<=50 sigue siendo
verdadera, se incrementa el valor de la variable en 1, y se ejecutan las
instrucciones contenidas dentro del ciclo.
- El proceso se repite hasta que la condición del ciclo se vuelva falsa; en
este caso sucederá cuando i valga 51. Para este valor de i el ciclo se
terminará, y el programa seguirá su ejecución con las instrucciones que
haya debajo del ciclo. Si no existen instrucciones, el programa se
terminará. Como las instrucciones se ejecutaron desde i=1 hasta i=50, y
por cada vuelta i se incrementó en 1, la cantidad de repeticiones será
50.

Nota: la notación usada para el incremento (i++) indica que la variable

aumentará su valor en 1 cada vez que el programa ejecute esa instrucción. Es
equivalente a i=i+1.

Veamos ahora como sería la resolución del enunciado planteado:

Dadas las edades de los 40 alumnos de un curso, calcular e informar cuántos

de ellos son mayores a 20 años.
 P

masde20=0

edad

i
edad>20
i=1 i<=40 i++

masde20=masde20+1

“La cantidad de alumnos

de más de 20 años es: “
masde20

El programa empieza asignándole un 0 a masde20 (la variable que se usará

para contar cuántos alumnos tienen más de 20 años). Luego se encuentra con
el ciclo exacto, le asigna a i un 1, chequea la condición (1<=40 Verdadero),
incrementa el valor de i en 1, y comienza la ejecución de las instrucciones
contenidas en el ciclo.

Dentro del ciclo exacto pide el ingreso de un valor de edad, se pregunta si ese
valor es mayor a 20, y si la respuesta es Verdadero incrementa en 1 el valor de
masde20.

Al finalizar el ciclo, cuando i tenga como valor 41 y por lo tanto 41<40 Falso, se
informará la leyenda “La cantidad de alumnos de más de 20 años es: “, y el
valor que contenga masde20.

En los lenguajes de programación para el ciclo exacto se usa la palabra for

(para en el idioma inglés).

2.3.2 Ciclo inexacto:

Supongamos que el enunciado del ejercicio anterior se reformulará de la
siguiente manera:
Dadas las edades de los alumnos de un curso, calcular e informar cuántos de
ellos son mayores a 20 años.

como no sabemos cuántos son los valores a evaluar, no podríamos usar un

ciclo exacto. Necesitaríamos otro ciclo que funcione independientemente de la
cantidad. Y eso es un ciclo inexacto.

El ciclo inexacto permite que un conjunto de instrucciones se repitan mientras

una determinada condición, que se evalúa antes de volver a repetir la
ejecución, sea verdadera.

La forma de representar el ciclo inexacto en nuestro lenguaje de diagrama de

flujo es la siguiente:

Proposición lógica

Instrucción o conjunto de
instrucciones
a ejecutar

Al encontrarse un programa con un ciclo inexacto se evalúa la proposición

lógica; si ésta es verdadera, se ejecutan las instrucciones que contiene el ciclo.
Una vez que la ejecución terminó, se vuelve a evaluar la proposición, y se
repite el proceso hasta que la condición se convierta en falsa. En este
momento el ciclo se termina, y el programa continúa la ejecución con las
instrucciones que sigan debajo del ciclo (si las hubiera).

Volviendo a nuestro ejemplo de las edades, al no tener una cantidad definida,

necesitamos establecer una forma para que el programa termine. Una
posibilidad es usar un valor en los datos que se ingresan como condición de
fin. El enunciado del ejercicio podría ser reformulado así:

Dadas las edades de los alumnos de un curso, calcular e informar cuántos de

ellos son mayores a 20 años. El programa debe finalizar cuando se ingrese un
valor de edad igual a 0.
El algoritmo de resolución es:
 P

masde20=0

edad

edad!=0

edad >20

masde20=masde20+1

edad

“La cantidad de alumnos

de más de 20 años es: “
masde20

El programa se inicia poniendo en 0 a masde20 (la variable que se utilizará

para contar cuántos alumnos tienen más de 20 años). Luego pide el ingreso de
un valor para edad; cumplido esto se encuentra con el ciclo inexacto, lo que lo
obliga a evaluar la condición edad!=0 (significa valor de edad distinto de 0). Si
el valor de verdad de la condición evaluada es Verdadero comienza la
ejecución de las instrucciones contenidas en el ciclo.

Dentro del ciclo se pregunta si el valor de edad es mayor a 20, y si la respuesta

es Verdadero incrementa en 1 el valor de masde20. Por último vuelve a pedir
el ingreso de un valor para edad. Como está dentro del ciclo, vuelve a evaluar
la proposición lógica edad!=0: si es verdadera ejecutará nuevamente las
instrucciones contenidas; si es falsa el ciclo termina.

Al finalizar el ciclo, cuando edad tenga como valor 0 y por lo tanto edad!=0
Falso, se informará la leyenda “La cantidad de alumnos de más de 20 años es:
“, y el valor que contenga masde20.

El mismo ejercicio puede ser resuelto de la siguiente manera:

 P

fin=0

masde20=0

fin==0

edad

edad!=0

edad>20 fin=1

masde20=masde20+1

“La cantidad de alumnos

de más de 20 años es: “
masde20

Esta resolución no usa directamente el valor de edad para finalizar, sino otra
variable (fin) a la que se le asignan 2 valores arbitrarios (0 como valor inicial, y
1 para diferenciarlo del anterior y conseguir que el ciclo se termine). Al
detectar un valor de edad igual a 0 se cambia el contenido de fin a 1, y el
programa se termina, ya que la proposición lógica que controla el ciclo se
convierte en falsa (1==0 Falso).

En todos los casos en que se utilice un ciclo inexacto, debe asegurarse que de
alguna manera el programa consiga que la proposición lógica se vuelva falsa;
caso contrario estaremos en presencia de un ciclo infinito. Un ciclo infinito no
puede formar parte de un algoritmo, ya que uno de las requisitos que se le
exigen a un algoritmo es que tenga fin.

En los lenguajes de programación para la decisión simple se usa la palabra

while (mientras en el idioma inglés).
Resumen Estructuras de programación

Teorema Fundamental de la Programación Estructurada: establece que

todo problema computacional – sin importar la complejidad de éste- puede
resolverse utilizando las siguientes estructuras de control:
- Estructura de secuencia.
- Estructura de decisión, o selección.
- Estructura de repetición o iteración.

Estas estructuras pueden combinarse entre si sin ningún tipo de restricción

para desarrollar cualquier programa.

Estructura de secuencia
La estructura secuencial establece el orden en el que se ejecutarán las
instrucciones. Todo programa es un conjunto ordenado de instrucciones. El
orden de ejecución está determinado por la ubicación de cada instrucción.

Estructura de decisión

Decisión simple (if)

Permite que un programa elija entre dos o más cursos posibles de acción por
si mismo. La elección del curso de acción está determinada por la respuesta
que el programa obtenga de la proposición lógica contenida en la decisión.

Toda proposición lógica o condición al evaluarse puede tener como resultado

Verdadero (si la condición se cumple) o Falso (si la condición no se cumple).

Decisión múltiple (switch)

La decisión múltiple permite que el programa elija uno entre varios (dos o
más) cursos probables de acción. El curso de acción que se seleccione
dependerá del valor que contenga la variable que se utilice como selectora.

Estructura de repetición
La estructura de repetición (o iteración) permite que una instrucción o un
conjunto de instrucciones se ejecuten de manera repetitiva, o en un ciclo. La
cantidad de veces que las instrucciones se repetirán está condicionada por el
conocimiento o no de la cantidad de datos a analizar, lo que da lugar a dos
formas distintas de implementación práctica de la estructura de repetición.

Ciclo exacto (for):

El ciclo exacto permite que un conjunto de instrucciones se repitan una
cantidad definida de veces. Esta cantidad debe ser conocida antes del inicio
del ciclo.

Ciclo inexacto (while):

El ciclo inexacto permite que un conjunto de instrucciones se repitan mientras
una determinada condición, que se evalúa antes de volver a repetir la
ejecución, sea verdadera.