UNIDAD6

DEPARTAMENTO DE ELECTRONICA
Y AUTOMATICA
UNIDAD 6
Programación Estructurada
Cátedra:
INFORMATICA I (BIO)
COMPUTACION I (ELO)
Índice
6 Programación Estructurada ................................................................................. 1

6.1 Introducción a la Programación..............................................................................1
6.2 Resolución de Problemas........................................................................................1
6.2.1 Etapas en la Resolución de Problemas..................................................................................1
6.3 Procesador, Ambiente, Acción y Condición...........................................................3
6.3.1 Procesador .............................................................................................................................3
6.3.2 Ambiente.................................................................................................................................3
6.3.3 Acción .....................................................................................................................................3
6.3.4 Técnica de Refinamientos sucesivos .....................................................................................3
6.3.5 Condición ................................................................................................................................5
6.3.6 Algoritmo.................................................................................................................................6
6.3.7 La Programación Estructurada como Herramienta de Diseño ...............................................7
6.4 El computador como Procesador ...........................................................................9
6.4.1 Constantes y Variables ...........................................................................................................9
6.4.2 Tipo Numérico ......................................................................................................................10
6.5 Expresiones............................................................................................................11
6.5.1 Expresiones Aritméticas .......................................................................................................11
6.5.2 Expresiones Relacionales ....................................................................................................14
6.5.3 Expresiones Lógicas.............................................................................................................14
6.5.4 Expresiones Cadena de Caracteres.....................................................................................15
6.6 Asignación de Variables ........................................................................................16
6.6.1 Asignación Aritmética ...........................................................................................................16
6.6.2 Asignación Lógica.................................................................................................................16
6.6.3 Asignación Carácter .............................................................................................................16
6.6.4 Asignación Cadena de Caracteres .......................................................................................16
6.6.5 Entrada de Datos ..................................................................................................................17
6.6.6 Salida de Datos.....................................................................................................................17
6.7 Estructuras de Control...........................................................................................17
6.7.1 Estructuras de Decisión........................................................................................................18
6.7.2 Estructuras de Decisión Generalizadas................................................................................20
6.7.3 Estructuras de Repetición.....................................................................................................22
6.8 Estructuras de datos..............................................................................................28
6.8.1 Introducción ..........................................................................................................................28
6.8.2 Definición y Características de los Arreglos de Datos..........................................................31
6.8.3 Implementación de Arreglos Multidimensionales .................................................................33
6.9 Guía de ejercicios...................................................................................................35
6.9.1 Ejercicios Resueltos .............................................................................................................35
6.9.2 Ejercicios Propuestos ...........................................................................................................38
COMPUTACIÓN I (ELO) - INFORMÁTICA I (BIO) UNIDAD VI: PROGRAMACIÓN ESTRUCTURADA
6 Programación Estructurada
6.1 Introducción a la Programación

En nuestro mundo se tienen problemas de diversos tipos, y la búsqueda de nuevos
conocimientos que experimenta el ser humano responde en gran medida a la necesidad de
resolver estos problemas. El hombre, utilizando los conocimientos, trata de encontrar una o
varias alternativas para la solución de dichos problemas.
La adquisición de nuevos conocimientos se realiza mediante dos caminos: uno es la
experiencia y el otro el esfuerzo por aprender a través de un sistema de enseñanza. De esta
manera tiene sentido el estudio de una determinada disciplina, lo cual permitirá resolver los
problemas que estén relacionados con ella.
Teniendo esto en cuenta, podemos decir que la Programación de Computadoras es una
disciplina de carácter intelectual orientada a resolver problemas genéricos que cumplan con
una serie de requisitos claramente establecidos. En particular, nos interesan los problemas
que pueden especificarse en forma clara y precisa.
Podemos definir un problema de la siguiente forma:
"Un problema es una situación desfavorable que puede especificarse en un número
finito de declaraciones, cuyo mejoramiento es posible en un tiempo finito y cuya
solución produce algún beneficio".
En programación interesan los problemas determinísticos, que son aquellos que se presentan
del mismo modo ante las mismas condiciones, cuya solución puede alcanzarse en un tiempo
razonable, y por sobre todo, que esa solución reporte algún beneficio. La programación no es
un fin en si mismo, sino que es un medio por el cual pueden resolverse problemas, y la
solución de un problema puede considerarse como la transformación de una situación
desfavorable. En algunos casos solo se dispondrá de información parcial del problema; por lo
que será necesario recurrir al sentido común para determinar el faltante.
6.2 Resolución de Problemas
6.2.1 Etapas en la Resolución de Problemas.

Se pueden considerar cinco etapas para la resolución de problemas:
Formulación o enunciación del problema
Un problema debe ser formulado en forma correcta, completa y sin ambigüedades. En
esta etapa deben definirse todas las circunstancias y restricciones vinculadas al
problema a los fines de tenerlas en cuenta. De nada sirve continuar con los pasos
posteriores si esta etapa no se ha cumplido con suficiencia.
Comprensión y Análisis
Una vez completado esto se debe realizar una comprensión del problema en el nivel
intelectual y se procede a realizar un análisis del mismo. Analizar significa
"desmenuzar" el problema en partes o problemas mas pequeños. De esta manera se
puede garantizar un conocimiento profundo y detallado del mismo.
Elección del procedimiento o método
Comprende la selección de la solución óptima de las posibles, si hubiera más de una
forma. En esta elección el criterio generalmente utilizado es el "económico" aunque en
algunos casos puede tener mayor peso otro, por ejemplo confiabilidad, rapidez.
1
Efectivización de la solución
Esta etapa también llamada "codificación" consiste en expresar el método o
procedimiento elegido de manera tal que pueda ser interpretado por el procesador que
llevara a cabo la solución.
Ejecución y evaluación de la solución
Es la última etapa y comprende la ejecución del procedimiento elegido y la evaluación
de los resultados obtenidos.
El análisis del enunciado debe hacerse teniendo en cuenta el conocimiento que posee el
encargado de lograr la solución del problema. El grado de desmenuzamiento no es igual para
un experto en determinado tema que aquel que recién se inicia.
Ejemplo:
T: Preparar una tortilla de papas
El enunciado de este problema basta para que un cocinero experto pueda resolverlo sin
información adicional, pero si este no es el caso, debemos describir los pasos necesarios para
realizar la preparación. Esta nueva descripción puede ser:
t1: mezclar papas, huevos y un poco de sal en un recipiente.
t2: freír.
Esto podría resolver el problema si el encargado de encontrar la solución no fuera una
persona que da sus primeros pasos en tareas relativas a la cocina, ya que esta forma de
expresión presupone muchas cosas. Si por el contrario este problema debiera resolverlo una
persona que no sabe cocinar, debemos detallar cada uno de los pasos mencionados, pues
estos, no son lo bastante simple para un principiante. Con este objetivo procederemos a
especificar los detalles de cada uno de los pasos, entonces:
Descomposición de t1:
t1.1: Cortar las papas en láminas.
t1.2: Dorar las papas.
t1.3: Batir los huevos en un recipiente.
t1.4: Colocar las papas en el recipiente con los huevos y poner un poco de sal.
t2.1: Calentar el aceite en la sartén.
t2.2: Colocar el contenido del recipiente en la sartén.
t2.3: Dorar la tortilla de ambos lados.
Este grado de descomposición quizás no sea suficiente, por que por ejemplo el ejecutor podría
ser un niño. En este caso se deberá explicitar aun más. Tomamos como ejemplo la subtarea
t1.3 que podría conducir a:
Descomposición de t1.3:
t1.3.1: Poner los tres huevos sobre la mesada.
Repita
t1.3.2: Tomar un huevo de la mesada.
t1.3.3: Romper el huevo y colocar su contenido en el recipiente.
t1.3.4: Tirar la cáscara a la basura.
hasta que no haya mas huevos sobre la mesada.
En este último paso se hizo uso de un esquema de repetición que fundamentaremos mas
adelante.
Ejercicios Propuestos:
2
1. Descomponer la subtarea t1.2 del ejemplo anterior.

2. Sumar los números 29 y 45 usando una calculadora de bolsillo. Suponga que no tiene
conocimiento de como utilizar la calculadora.
6.3 Procesador, Ambiente, Acción y Condición

Hasta ahora se han mencionado superficialmente algunos elementos que intervienen en el
problema y en su solución, a continuación se darán una serie de definiciones.
6.3.1 Procesador
Es toda entidad (cosa o persona) capaz de "entender o mejor dicho INTERPRETAR" un
! enunciado y ejecutar el trabajo indicado por él. En otras palabras es quien materializa las
acciones necesarias para solucionar el problema.
6.3.2 Ambiente
! Es el conjunto de recursos y consideraciones necesarias para la ejecución de una tarea. Si el

ambiente no provee los elementos necesarios el procesador no podrá ejecutar el trabajo.
Analicemos un ejemplo para ilustrar las afirmaciones realizadas.
Una persona se encuentra en la calle y debe efectuar una llamada telefónica. Consideremos
tres casos posibles.
1. No funciona ningún teléfono público en la zona.
2. Los teléfonos funcionan pero la persona no tiene tarjeta telefónica.
3. Los teléfonos públicos funcionan y la persona posee la tarjeta.
• En el primer caso, EL PROCESADOR (La persona) no puede en función del AMBIENTE
(Teléfono público), efectuar el trabajo propuesto.
• En el segundo caso, EL PROCESADOR decidirá entre no hablar e ir a comprar una tarjeta.
• En el tercer caso EL PROCESADOR podrá realizar la llamada sin ninguna dificultad. Es de
hacer notar que AMBIENTE y trabajo están íntimamente ligados.
6.3.3 Acción
! Es cada uno de los pasos o etapas que el procesador ejecuta para llegar a la solución o
Acción es todo evento que modifica el ambiente. Las Acciones son Verbos.
Acción Primitiva
! Para un procesador dado una acción es primitiva, si su enunciado es suficiente para que
pueda realizarla sin información adicional.
Acción No Primitiva o Acción Compuesta
Son aquellas en que su enunciado no puede ser interpretado directamente por el procesador,
por lo tanto debe ser descompuesta en acciones cada vez mas simples hasta que cada una de
ellas sea una acción primitiva.
6.3.4 Técnica de Refinamientos sucesivos

Existen distintas técnicas que permiten descomponer una acción compuesta en acciones
primitivas. Uno de los métodos, denominado técnica de refinamientos sucesivos o método
Top-Down, consiste en:
3
Dado un trabajo T, por medio de un enunciado no primitivo, tal que transforme el ambiente,
! desde un estado inicial Ei en un estado final Ef, es posible encontrar una descomposición t1,
t2,..... tn, que constituyan una secuencia de enunciados que ejecuten el trabajo T.
t1.1
Ei = Ei1
t1.2
t1
Ei2 = Ef1
Ei t2 t1.m
Ei3 = Ef2
Ef
T t3
Ei4 = Ef3
Ef
Ein = Efn-1
tn
Efn = Ef
Figura 6.1 - Técnica de refinamientos sucesivos
Como se observa en la figura 6.1, cada trabajo tk, transforma el ambiente de un estado Eik
(estado inicial para la tarea k) en un estado final Efk (estado final de la tarea k) y que a su vez
es el estado inicial para la tarea k+1.
Para cada enunciado tk existen dos posibilidades, a saber:
tk es una acción primitiva para el procesador, dando así por terminada la descomposición de
tk.
tk no es una acción primitiva para el procesador debiéndose descomponer esta en una
secuencia tk1,tk2,.....tkn.
Para aclarar las diferencias entre acciones primitivas y compuestas consideremos el siguiente
trabajo.
“Preparar sopa para cuatro personas”
• Si el procesador es un cocinero experimentado el interpretará este enunciado, por lo tanto
para este procesador esta es una acción primitiva.
• Si el procesador es una persona con escasos conocimientos de cocina, no sabrá
interpretar el enunciado y habrá que descomponerlo en una serie de acciones menores,
las cuales podrán interpretar y por lo tanto estas serán acciones primitivas, por ejemplo:
tomar una olla de 1,5 lts.
verter 1 lt de agua
poner a calentar la olla
pelar las verduras
.................
4
etc.
6.3.5 Condición
! Una Condición es una afirmación lógica sobre el estado del problema, que en el momento de
la observación puede ser verdadera o falsa.
El procesador determina, en el momento de la ejecución del trabajo, las acciones a seguir,
dependiendo si la condición es satisfecha o no. No debe confundirse una condición con una
acción, las acciones son verbos (Leer, Sumar, Repartir, Escribir, etc) y modifican el ambiente
mientras que las condiciones se utilizan para determinar cuando se da por finalizado un
determinado proceso (es una pregunta sobre el estado del ambiente).
A los fines de reafirmar los conceptos vistos e introducir algunos nuevos, se analizará el
siguiente ejemplo.
T: Se desea repartir entre cuatro niños, caramelos de frutilla, menta y naranja, contenidos en
una bolsa no transparente. La persona que debe repartir los caramelos (procesador), para
evitar conflictos, dará a cada niño la misma cantidad de caramelos de cada gusto, suponiendo
al iniciar que la bolsa contiene por lo menos cuatro del mismo gusto.
Para ejecutar el trabajo el procesador dispone del siguiente ambiente:
• cuatro niños.
• bolsa conteniendo caramelos de frutilla, menta y naranja.
• tres cajas, una para cada gusto.
Las acciones primitivas del individuo (procesador) son:
• tomar un caramelo de la bolsa.
• poner un caramelo en la caja correspondiente.
• tomar cuatro caramelos de una caja y distribuirlos.
Las condiciones que interpreta el procesador son:
• bolsa vacía.
• una caja contiene menos de cuatro caramelos.
El trabajo a realizar puede ser descripto por el siguiente enunciado:
T. repartir los caramelos de frutilla, menta y naranja entre cuatro niños de manera tal que a
cada uno le corresponda la misma cantidad de caramelos de cada gusto.
Este enunciado no representa las acciones primitivas posibles de realizar por nuestro
procesador. Por lo tanto T debería descomponerse. Una primera descomposición es la
siguiente:
t1. repartir los caramelos que están en la bolsa, en tres cajas, de acuerdo al gusto.
t2. tomar los caramelos de las cajas y distribuirlos entre los cuatro niños.
Las acciones t1 y t2, que son independientes entre sí, no constituyen aún acciones primitivas
para nuestro procesador, por lo tanto debemos continuar con la descomposición.
Repita
t1.1 tomar un caramelo de la bolsa
t1.2 poner el caramelo en la caja correspondiente al gusto
hasta que (t1.3) la bolsa esté vacía.
5
Las acciones t1.1 y t1.2 son primitivas y la condición t1.3 puede ser interpretada por el
procesador, por lo tanto la descomposición de t1 ha terminado.
t2.1. distribuir entre los cuatro niños, los caramelos de frutilla hasta que en la caja que
los contiene haya menos de cuatro.
t2.2. distribuir entre los cuatro niños, los caramelos de menta. Hasta que ..........
t2.3. distribuir entre los cuatro niños, los caramelos de naranja. Hasta que ......
Esta descomposición de t2 aún no contempla tareas primitivas. La acción t2.1 puede
descomponerse en forma de operaciones primitivas de la siguiente forma:
Repita
t2.1.1 tomar cuatro caramelos de la caja de frutilla y distribuirlos entre los cuatro
niños.
hasta que (t2.1.2) la caja de caramelos de frutilla contenga menos de cuatro unidades.
De forma similar se deben descomponer las acciones t2.2 y t2.3. De esta manera el problema
T por medio del método de refinamientos sucesivos (top-down) se ha descompuesto en una
serie de operaciones primitivas.
La secuencia final de acciones primitivas obtenida se llama "Algoritmo" y para este ejemplo
es:
Inicio
Repita
tomar un caramelo de la bolsa
poner un caramelo en la caja del gusto correspondiente
hasta que la bolsa esté vacía
Repita
tomar 4 caramelos de la caja de frutillas y distribuirlos
hasta que la caja de frutilla contenga menos de 4 caramelos
Repita
tomar 4 caramelos de la caja de menta y distribuirlos
hasta que la caja de menta contenga menos de 4 caramelos
Repita
tomar 4 caramelos de la caja de naranja y distribuirlos
hasta que la caja de naranja contenga menos de 4 caramelos
6.3.6 Algoritmo
Es una secuencia ordenada de acciones primitivas que pueden ser ejecutadas por un
! procesador y, que lleva a la solución de un problema dado.
Los conceptos de algoritmo y de método son parecidos: los métodos para realizar
determinadas tareas forman parte de las costumbres o rutinas que el hombre aprende un día y
luego las repite de manera inconsciente, sin tener en cuenta las acciones más sencillas que
integran el proceso (por ejemplo caminar, leer o conducir). Por eso el concepto de algoritmo
suele considerarse como un método o rutina de acciones.
Una definición de algoritmo indicaría que es la descripción precisa de los pasos que nos llevan
a la solución de un problema planteado. Estos pasos son, en general, acciones u operaciones
que se efectúan sobre ciertos objetos. La descripción de un algoritmo afecta a tres partes: la
entrada (los datos), el proceso (las instrucciones) y la salida (los resultados). En este sentido,
un algoritmo se puede comparar a una función matemática.
6
A continuación se resolverá el mismo problema anterior pero sin tener en cuenta la suposición
de que inicialmente la bolsa contiene por lo menos cuatro caramelos de cada gusto.
En estas condiciones el esquema de solución adoptado antes:
Repita
tomar 4 caramelos de la caja de naranja y distribuirlos
hasta que la caja de naranja contenga menos de 4 caramelos.
Fallaría si inicialmente la bolsa contuviera 3 o menos caramelos de naranja!!!
Esto indica que se debe buscar otra estructura de repetición la cual puede ser la siguiente:
mientras haya por lo menos 4 caramelos
hacer
tomar 4 caramelos de la caja y distribuirlos
fin mientras
Esta otra estructura de repetición, aunque similar a la "Repita", se diferencia de ella en que la
condición se evalúa antes de ejecutar ninguna acción.
En programación estructurada existen una serie de estructuras tipo mediante las cuales es
posible resolver cualquier problema. Los computadores no pueden ejecutar directamente los
algoritmos en forma literal como en el ejemplo, y para que puedan hacerlo es necesario
codificarlos en un lenguaje apropiado que llamaremos "Lenguaje de Programación" y al
Algoritmo así codificado le llamaremos "Programa".
6.3.7 La Programación Estructurada como Herramienta de Diseño

La visión clásica de la programación estructurada se refiere al control de ejecución de un
programa o algoritmo. El control de ejecución es una de las aspectos más importantes que
hay que tener en cuenta al construir un algoritmo. La regla general es que las acciones se
ejecuten sucesivamente una tras otra, pero diversas partes del programa se ejecutan o no
dependiendo de que se cumpla alguna condición. Además, hay acciones que deben
ejecutarse varias veces, ya sea en número fijo o hasta que se cumpla una condición
determinada.
Sin embargo, algunas técnicas algorítmicas más antiguas se apoyaban en una sola instrucción
para modificar la secuencia de ejecución de las instrucciones mediante una transferencia
incondicional de su control (con la infame instrucción goto, del inglés "go to", que significa "ir
a"). Pero estas transferencias arbitrarias del control de ejecución hacen los algoritmos muy
poco legibles y difíciles de comprender. A finales de los años sesenta, surgió una nueva forma
de programar que reduce a la mínima expresión el uso de la instrucción goto y la sustituye por
otras más comprensibles y ordenadas
Esta forma de programar se basa en un famoso teorema, desarrollado por Edsger Dijkstra,
que demuestra que todo programa puede escribirse utilizando únicamente las tres estructuras
básicas de control siguientes:
Secuencia: el bloque secuencial de instrucciones, instrucciones ejecutadas
sucesivamente, una detrás de otra.
Selección: la instrucción condicional con doble alternativa, de la forma "SI condición
ENTONCES acción-1 SINO acción-2".
Iteración: el bucle condicional "MIENTRAS condición HAGA acción", que ejecuta la
instrucción repetidamente mientras la condición se cumpla.
Los programas que utilizan sólo estas tres instrucciones de control básicas o sus variantes
(que se verán a continuación), pero NO la instrucción goto, se llaman estructurados.
7
Ésta es la noción clásica de lo que se entiende por programación estructurada (llamada

también programación sin goto) que hasta la aparición de los nuevos paradigmas (como la
programación orientada a objetos [POO]) se convirtió en la forma de programar más
extendida.
Una característica importante de un programa estructurado es que puede ser leído en
secuencia, desde el comienzo hasta el final sin perder la continuidad de la tarea que cumple el
programa, lo contrario de lo que ocurre con otros estilos de programación.
Este hecho es importante debido a que es mucho más fácil comprender completamente el
trabajo que realiza una acción determinada si todas las instrucciones que influyen en su
quehacer están físicamente contiguas y encerradas por un bloque. La facilidad de lectura, de
comienzo a fin, es una consecuencia de utilizar solamente tres estructuras de control, y de
eliminar la instrucción de transferencia de control goto.
La visión moderna de la programación estructurada: La Segmentación
La realización de un algoritmo sin seguir alguna técnica establecida de desarrollo produce
! frecuentemente un conjunto enorme de sentencias cuya ejecución es compleja de seguir, y de
entender, pudiendo hacer casi imposible la depuración de errores y la introducción de mejoras.
Se puede incluso llegar al caso de tener que abandonar el código preexistente porque resulte
más fácil empezar de nuevo.
Cuando en la actualidad se habla de programación estructurada, nos solemos referir a la
división de un algoritmo en partes más manejables (usualmente denominadas segmentos o
módulos).
Así, la visión moderna de un algoritmo estructurado es un compuesto de segmentos, los
cuales puedan estar constituidos por unas pocas acciones o por muchas de ellas. Cada
segmento tiene solamente una entrada (comienzo de la ejecución) y una salida (fin de la
ejecución), asumiendo que no poseen bucles infinitos y que no tienen acciones que jamás se
ejecuten. Encontramos la relación entre ambas visiones, la clásica y la moderna, en el hecho
de que los segmentos se combinan utilizando las tres estructuras básicas de control
mencionadas anteriormente y, por tanto el resultado es también un algoritmo estructurado.
Cada una de estas partes englobará acciones (funciones) y datos íntimamente relacionados
semántica o funcionalmente. En una correcta partición del algoritmo deberá resultar fácil e
intuitivo comprender lo que debe hacer cada módulo.
En una segmentación bien realizada, la comunicación entre segmentos se lleva a cabo de una
manera cuidadosamente controlada. Así, una correcta partición del problema producirá una
nula o casi nula dependencia entre los módulos, pudiéndose entonces trabajar con cada uno
de estos módulos de forma independiente. Este hecho garantizará que los cambios que se
efectúen a una parte del algoritmo, durante el desarrollo original o su mantenimiento, no
afecten al resto del algoritmo que no ha sufrido cambios.
Esta técnica de programación conlleva las siguientes ventajas:
El coste de resolver varios subproblemas relativamente pequeños de forma aislada es con
frecuencia menor que el de abordar el problema global.
Facilita el trabajo simultáneo (en paralelo) de distintos grupos de programadores.
Posibilita en mayor grado la reutilización del código (especialmente de alguno de los
módulos) en futuras aplicaciones.
Aunque no puede fijarse de antemano el número y tamaño de estos módulos, debe intentarse
un compromiso entre ambos factores. Si nos encontramos ante un módulo con un tamaño
excesivo, podremos dividir éste a su vez en partes (nuevos módulos) más manejables,
produciéndose la sucesiva división siempre desde problemas generales a problemas cada vez
menos ambiciosos y, por tanto, de fácil desarrollo y seguimiento. Así, esta división toma la
forma de un árbol cuya raíz es el programa principal que implementa la solución al problema
que afrontamos utilizando uno o varios módulos que realizan partes de dicha solución por sí
8
solos o invocando a su vez otros módulos que solucionan subproblemas más específicos. A
esta aproximación se la denomina diseño descendente o top-down, y queda esquematizado
en la siguiente figura:
Fig. 5.1. Diseño descendente.

El carácter autocontenido de los módulos hace que pueda llegar a ocultarse el funcionamiento
interno de las funcionalidades contenidas en un módulo, lo que a su vez realza la relación
entre los mismos separándolos del resto del programa.
6.4 El computador como Procesador

Estando definidos en general los conceptos de procesador, ambiente, acción, condición y
algoritmo; se estudian a continuación las condiciones particulares que se tienen cuando el
procesador es un computador. En este caso el ambiente estará formado por los recursos de la
computadora, por ejemplo: memoria, pantalla, teclado, impresora, unidad de disco, etc.
6.4.1 Constantes y Variables

El elemento mas utilizado por la CPU en la resolución de un algoritmo es la memoria de la
máquina que esta dividida en lugares donde el procesador deposita o extrae información. En
programación a estos lugares de memoria se los suele llamar objetos. Los contenidos de
estos objetos pueden permanecer inalterables durante la ejecución de un algoritmo o se
puede ir modificando su valor durante la ejecución.
A los primeros se les llama "constantes" y a los segundos "variables".
Una constante es un objeto cuyo valor no puede variar. Una variable es un objeto cuyo valor
puede variar y además posee los siguientes atributos:
• un nombre
• un tipo
• un valor
Cuando se define una variable, se debe precisar su nombre y tipo. Definir una variable es
crear un objeto para el procesador. En otros términos seria que el procesador asigne lugar o
lugares de memoria a esa variable, la cantidad de lugares a asignar depende del tipo de
variable.
Los tipos de datos primitivos que pueden manejar la mayoría de los procesadores son:
• numéricos
• lógicos
• carácter
9
6.4.2 Tipo Numérico

Como su nombre lo indica puede representarse el conjunto de los valores numéricos y en
general se tiene en dos formas distintas:
• entero.
• real.
6.4.2.1 Tipos Numéricos Enteros

Este tipo es un subconjunto finito de los números enteros, los números enteros que pueden
representarse son todos los números enteros comprendidos entre los números máximos y
mínimos que acepta el computador los cuales son comúnmente -32768 y 32767. La
determinación de estos valores máximos y mínimos se debe a que normalmente la
computadora asigna dos bytes de memoria (16 bits) para representar los valores enteros, pero
esto puede variar según las características de la CPU en cuestión.
6.4.2.2 Tipo Numérico Real

El tipo real es un subconjunto de los números reales, y en este tipo es donde se representan
los números con punto decimal. Generalmente, las computadoras utilizan la representación de
punto flotante IEEE-754, donde se definen una cierta cantidad de dígitos significativos y un
exponente (este es el concepto de notación científica estudiada). La computadora almacena
los números reales en forma similar a la descrita, la parte fraccionaria o mantisa y la parte
exponencial.
Por ejemplo el número 0,00543820 con ocho dígitos de precisión en el formato de punto
flotante normalizado se expresa como:
0,54382000 * 10-2
6.4.2.3 Tipo Lógico (Booleano)

El tipo lógico también llamado tipo Booleano es el conjunto de los dos valores lógicos posibles,
verdadero y falso.
V verdadero F falso
6.4.2.4 Tipo Carácter

Cada computador reconoce un conjunto finito y ordenado de caracteres, pero en general,
todos los computadores pueden manipular los siguientes:
a. el conjunto de las letra mayúsculas
b. el conjunto de las letras minúsculas
c. conjunto de los dígitos decimales
d. el carácter de espacio en blanco
e. caracteres especiales como *, +, -, $, etc.
Una constante de tipo carácter se escribe entre apóstrofes para evitar confundirlo con
nombres de variables, operadores, enteros, etc.
Por ejemplo si X es una variable entera e Y una variable de tipo carácter, se tiene:
X = 8 indica que a la variable numérica X se le asigna el número 8.
Y = '8' indica que a la variable carácter Y se le asigna el carácter 8.
10
La diferencia reside en que con X se pueden realizar todas las operaciones aritméticas
mientras que con Y sólo las operaciones permitidas con caracteres.
Si se llegara a definir:
Y=8
Se estaría cometiendo un error ya que a una variable carácter Y se le estaría asignando un
valor numérico, también sería incorrecto si se le asignara una sucesión de caracteres, por
ejemplo,
Y = 'abc'
6.4.2.5 Tipo Cadena de Caracteres

Cadena de caracteres es una secuencia finita y no vacía de caracteres encerrados entre
comillas,
Ejemplo:
"$1255,20" "Informática"
La longitud de la cadena se define como la cantidad de caracteres delimitados por las comillas
incluyendo los blancos mas uno. Una variable cuyo valor es una cadena de caracteres se
denomina variable cadena o variable hilera (string). Las cadenas de caracteres no forman
parte del conjunto de datos primitivos, son datos estructurados (arreglos).
6.5 Expresiones
Un procesador debe ser capaz de manejar los datos descritos en el ambiente de un algoritmo,
por Ej. 5+8, 2*5, etc.
Una expresión describe un cálculo a efectuar por el procesador y cuyo resultado es único.
Una expresión contiene operandos y operadores. Según el tipo de datos que maneja se
clasifican en:
• Expresiones aritméticas
• Expresiones relacionales
• Expresiones lógicas
• Expresiones carácter
El resultado de una expresión aritmética es del tipo numérico, el correspondiente a una
expresión relacional o a una expresión lógica es del tipo lógica y el resultado de una expresión
carácter es del tipo carácter o cadena.
6.5.1 Expresiones Aritméticas

Las expresiones aritméticas se forman utilizando los operadores indicados en la Tabla 6.1. Los
operandos utilizados en estas expresiones pueden ser:
• Constantes numéricas.
• Variables numéricas.
• Expresiones aritméticas entre paréntesis.
Operador
Función
Aritmético
+ Suma
11
Operador
Función
Aritmético
- Resta
* Producto
/ División
^ Potenciación
mod Resto de la división entera
div División entera
Paréntesis para agrupar

( ) expresiones
Los primeros cinco operadores no requieren explicación, pero esta si es necesaria para el
operador mod (llamado también operador Módulo) el cual entrega como salida el resto de la
división entera; y para el operador div, quien entrega el resultado de la división entera. Para
estos operadores se debe tener en cuenta lo siguiente:
Si se tienen dos valores enteros 5 y 2, la división entera de estos operandos no da como
resultado 2.5, valor que se obtendría en una calculadora, esto es por que este valor 2.5 no es
un entero, la división entera de 5/2 nos entrega dos resultados: el cociente 2 y el resto 1.
5 2
1 2 Cociente
Resto
Una aplicación trivial de este operación esta dada en su utilización para determinar si un
número entero es par o no
Si x mod 2 = 0 entonces x es par
=1 entonces x es impar
En cuanto al signo, si uno de los operandos es negativo, el signo del resto resultara de aplicar
las reglas de los signos del álgebra, teniendo en cuenta que siempre debe cumplirse lo
siguiente:
Si A es el dividendo y B el divisor, entonces:
A = (A div B) * B + (A mod B)
Por ejemplo si A = -5 y B = 2
La operación resto dará por resultado -1 para que se cumpla la expresión anterior.
Reglas con las que se evalúa una expresión de dos o más operandos:
12
a) todas las cantidades que están encerradas entra paréntesis se evalúan primero, siendo las
primeras en evaluarse las más internas en el caso de un anidado.
b) las operaciones aritméticas dentro de una expresión, se ejecutan de acuerdo con el
siguiente orden de precedencia
Orden Operador Significado
Se aplica de Derecha a
1 ^ Izquierda
Se aplica de Izquierda a
2 *, / , div, mod Derecha
Se aplica de Izquierda a
3 +, - Derecha
Ejemplo:
Indicar en que orden se realizan las operaciones y ¿cual es el resultado de la siguiente
expresión?
10 − 7 + 3 * ((52
12 −3
12) / 5)
40
10 − 7 + 3 * (40 / 5)
123
8
10 − 7 + 3{
*8
24
10
12 −37 + 24
3
31+
2324
27
27
Además de las operaciones básicas como suma, resta, producto, división y potencia puede
existir otro conjunto de operadores especiales que se denominan funciones internas y algunos
ejemplos se listan en la siguiente tabla.
Estas funciones no Nombre de Significado

están disponibles en Función
el entorno LPP!!!
ABS Valor Absoluto
RC Raíz Cuadrada
LOGN Logaritmo Natural
LOG10 Logaritmo Decimal
EXP Exponencial (base e)
SEN Seno
COS Coseno
TAN Tangente
TRUNC Truncamiento
REDON Redondeo
13
6.5.2 Expresiones Relacionales

Las expresiones relacionales nos permiten realizar comparaciones entre valores del mismo
tipo.
Se debe tener en cuenta que el resultado de una expresión relacional es siempre de tipo
lógico o también llamado Booleano, o sea Verdadero (v) o Falso (f). A las funciones
preposicionales se les suele denominar predicados.
Operador
Significado
Relacional
= Igual
< Menor
<= Menor o igual
> Mayor
>= Mayor o igual
<> Distinto
Ejemplo:
Si A y B son dos variables numéricas cuyos valores son respectivamente, 3 y 15, la siguiente
tabla muestra el cálculo de algunos predicados:
Predicado Valor
A>B f
A=B f
A<B v
A<>B v
También es posible la comparación entre cadenas de caracteres, en este caso la comparación

se efectúa de izquierda a derecha y el ordenamiento es alfabético.
De esta manera la constante "TOMAS" es menor que la constante "TOMATE".
Los predicados elementales o expresiones relacionales pueden combinarse, mediante los
llamados conectores u operadores lógicos, para formar predicados compuestos.
6.5.3 Expresiones Lógicas

Los operadores lógicos utilizados en expresiones lógicas son los que se muestran en la tabla
siguiente:
Operador Lógico Operador Lógico Significado
Y AND Conjunción o Producto Lógico
14
Operador Lógico Operador Lógico Significado
O OR Disyunción Inclusiva o Suma Lógica
NO y NE no están NO NOT Negación

disponibles en el
entorno LPP!!! NE XOR Disyunción Exclusiva
Los resultados de las operaciones con estos operadores es un valor lógico que depende de
las leyes del álgebra de Boole.
Para evaluar las expresiones lógicas se debe recurrir a las tablas de verdad. Las tablas de
verdad de los operadores lógicos mencionados anteriormente son las siguientes:
Siendo A y B proposiciones, v y f verdadero y falso
respectivamente:
Producto Lógico Suma Exclusiva
A B AYB A B A NE B
v v v v v f
v f f v f v
f v f f v v
f f f f f f
Suma Lógica Negación Lógica

A B AOB A NOT A
v v v v f
v f v f v
f v v
f f f
El orden de precedencia de los operadores lógicos es:
Orden Operador
1 NO
2 Y
3 O y NE
6.5.4 Expresiones Cadena de Caracteres

La operación básica con cadenas de caracteres consiste en tomar dos cadenas y reunirlas en
una sola. Esta operación se denomina concatenación, y se simboliza por +. Por ejemplo si se
tienen dos cadenas de caracteres,
"Programa"
"ción Lógica"
"Programa" + "ción Lógica” el resultado es "Programación Lógica"
El operador concatenación (+) es asociativo.
15
6.6 Asignación de Variables

Para asignar a una variable un valor que proviene de un ambiente dado, utilizaremos la
siguiente notación:
nombre_de_variable valor
V E
Donde:
• V es el nombre de la variable a la que el procesador le va a asignar el valor de E .
• es el signo de la asignación y es el símbolo “<” seguido del símbolo “-”
• E representa el valor que se le va a asignar a la variable.
Según sea el tipo de variable V y E , la acción de asignar se puede clasificar en:
• asignación aritmética
• asignación lógica
• asignación de carácter
• asignación Cadena de Caracteres
6.6.1 Asignación Aritmética

V E Será una asignación aritmética si:
V Es una variable de tipo numérico.
E Es una constante de tipo numérico, una variable de tipo numérico o una expresión
aritmética.
6.6.2 Asignación Lógica

V E Será una asignación lógica si:
V Es una variable lógica.
E Es una constante lógica, una variable lógica, una expresión relacional o una expresión
lógica.
6.6.3 Asignación Carácter

V E Es una asignación carácter si:
V Es una variable de tipo carácter.
E Es una constante de tipo carácter o una variable de tipo carácter.
6.6.4 Asignación Cadena de Caracteres

V E Será una asignación cadena de caracteres si:
V Es una variable tipo cadena de caracteres.
E Es una constante tipo cadena de caracteres, una variable tipo cadena de caracteres, una
expresión tipo cadena de caracteres o una expresión tipo carácter.
16
6.6.5 Entrada de Datos

Un valor que no pertenece al ambiente puede introducirse a éste mediante una acción que
realiza el procesador, y que se denomina Lectura.
Lectura
Es toda acción que permite la entrada de un valor al ambiente a través de un dispositivo.
Una lectura de un dato es considerado una asignación, ya que el valor leído del medio externo
es asignado a una de las variables del ambiente, la lectura se puede considerar como una
acción primitiva que notaremos con el siguiente formato:
Lea V
Donde V es una variable del ambiente que recibe un valor de un dispositivo, por ejemplo,
desde un teclado.
6.6.6 Salida de Datos

Un valor del ambiente puede "salir" del mismo para comunicar alguna información al medio
externo, por ejemplo a través de una pantalla o la impresión sobre un papel, exteriorizando
algún resultado.
Escritura
Es toda operación que permite la salida de un valor del ambiente a través de un dispositivo.
La escritura es una acción primitiva que la notaremos con el siguiente formato:
Escriba V
Donde V es la variable, cuyo valor se desea transferir al medio externo.
Analicemos algunos ejemplos que muestran su utilización:
Escriba A,B,C /* Escribirá el valor de las variables A, B y C en “Pantalla” */
Escriba "Informática I" /*Escribirá el valor constante Informática I en “Pantalla”*/
Escriba "El valor del Promedio es: ", P /*Escribirá el valor constante: El valor del Promedio es:
y */
a continuación el valor numérico correspondiente a la variable P en “Pantalla”
6.7 Estructuras de Control

La potencia de un procesador proviene en gran parte de su capacidad para tomar decisiones,
estableciendo que acción debe realizar en un determinado paso en la ejecución de un
algoritmo, dependiendo de los valores de los datos que se leen o bien de los resultados de los
cálculos que se han realizado en pasos anteriores.
Dentro de las estructuras de control existen dos conceptos importantes para la toma de
decisiones:
1. La selección de una acción entre un conjunto de alternativas específicas.
! 2. La repetición de un conjunto de acciones.
Se llama flujo de control de un algoritmo, al orden en el cual se deben ejecutar las acciones
primitivas. Dentro del flujo de control se puede citar, el flujo lineal de control, es decir, la
ejecución secuencial de acciones, desde la primera hasta la última, las estructuras de control
son las que permiten apartarse del flujo lineal. Una de estas estructuras le permite al
procesador repetir, automáticamente, un grupo de acciones, como por ejemplo el esquema
"Repita-hasta que" visto en los temas anteriores, otras permiten seleccionar una acción entre
17
otra u otras posibles, según se evalúen determinadas condiciones. De esta manera se tienen
en la Programación Estructurada, dos tipos o clases de estructuras de control bien
diferenciadas que son:
• Estructuras de Decisión
• Estructuras de Repetición o de Lazo
6.7.1 Estructuras de Decisión
6.7.1.1 Estructura si-fin si

Para conocer su funcionamiento, analicemos una aplicación.
Supongamos tener dos variables numéricas, x e y cuyos valores son diferentes y se desea
escribir el mayor de ellos. Si x es mayor que y debe escribirse el valor de x, de lo contrario, si
y es mayor que x debe escribirse el valor de y. El siguiente gráfico representa esta estructura:
Verdadero
Escriba x
x>y
Falso
Escriba y
La expresión x > y es un predicado que describe una condición que se desea probar. Si x > y
es verdadera se ejecuta la acción escribir x, si x > y es falsa, se ejecuta la acción de la
derecha, o sea escribir y. En este ejemplo se ha visto una de las estructuras más importantes
en el diseño de algoritmos, la selección de una acción entre dos alternativas dependiendo de
una condición.
Esta estructura algorítmica se denomina: construcción
"si-entonces-sino-fin si"
y su formato es el siguiente:
si (condición) entonces
alternativa verdadera
sino
alternativa falsa
fin si
La construcción comienza con la palabra si, seguida de la condición que se debe evaluar. Si la
condición es verdadera la alternativa que debe ejecutarse es la verdadera, la cual se
encuentra precedida por la palabra entonces. La otra alternativa que debe ejecutarse si la
condición resulta falsa (alternativa falsa), está precedida por la palabra sino, la estructura
debe finalizarse con fin si. A las palabras si, entonces, sino, fin si, se le llama delimitadores.
El ejemplo anterior tomará la siguiente forma:
18
si x > y entonces
escriba x
sino
escriba y
fin si
Es de hacer notar que tanto la condición como cada una de las alternativas, pueden ser más
complejas. La condición puede estar comprendida por predicados compuestos y las
alternativas pueden comprender varias acciones primitivas.
ENTRADA
V EVALUA F
CONDICION
ENTONCES SINO
EJECUTA ACCIONES EJECUTA ACCIONES

ALTERNATIVA VERDADERA ALTERNATIVA FALSA
SALIDA
Esta estructura de decisión se la considera como un ente completo, al que se entra por arriba
y se sale por abajo. Es importante resaltar un concepto básico de la Programación
Estructurada, que es la existencia de un sólo punto de entrada y un solo punto de salida. Es
de hacer notar que parte correspondiente a la alternativa falsa puede no estar presente.
Analizaremos un ejemplo:
Enunciado:
Calcular la raíz cuadrada de un número si éste no es negativo, en caso contrario escribir un
mensaje.
Método:
Leer un número, si su valor es positivo o cero, entonces, calcular su raíz, sino, escribir un
cartel aclaratorio.
real d, A
Inicio
escriba " Ingrese el dato a procesar "
lea d
si d >= 0 entonces
A d*d
escriba A
sino
escriba "número negativo"
fin si
fin
19
Un caso particular de esta estructura ocurre si no existen acciones a ejecutar cuando la

condición es falsa, en este caso no aparecerá el delimitador sino y el formato quedará como
sigue:
si (condición) entonces
alternativa verdadera
fin si
6.7.1.2 Anidamiento de Estructuras de Decisión

Tanto la alternativa verdadera como la falsa, pueden contener a su vez, estructuras de
decisión en su cuerpo.
Analicemos un ejemplo:
Enunciado:
Se leen tres números, A, B y C y se pide escribir el mayor de ellos.
Método:
Se compara A con B; si A es mayor que B entonces, se compara A con C, si A es mayor que
C entonces, el mayor es A, sino el mayor es C. Si A no es mayor que B entonces se deben
comparar B y C para determinar el mayor.
real A,B,C
inicio
Escriba “ Ingrese los datos a procesar “
lea A, B, C
si A > B entonces
si A > C entonces
Escriba "el máximo valor es:",A
sino
Escriba "el máximo valor es:",C
fin si
sino
si C > B entonces
Escriba "el máximo valor es:",C
sino
Escriba "el máximo valor es:",B
fin si
fin si
fin
6.7.2 Estructuras de Decisión Generalizadas

Esta es una estructura de decisión más práctica para algunas aplicaciones, se la denomina
estructura de decisión generalizada o también estructura de decisión múltiple y su forma es la
siguiente:
20
caso E
E1:
acción 1
E2:
acción 2
............
............
Ek:
acción k
sino:
acción B
fin caso
En esta estructura, E es una expresión numérica, cuyo resultado puede ser uno de los valores
E1, E2, ...Ek en función de estos valores, se ejecutará una y sólo una de las acciones
indicadas. Si por ejemplo E tiene el valor Ei, la acción i es ejecutada. En caso de que el valor
de E sea distinto de E1, E2, ...Ek, se ejecuta la acción B.
Ejemplo:
Día es una variable numérica entera y sus valores posibles son: 1, 2, ...,7. Se pide diseñar un
algoritmo que escriba los nombres de los días de la semana correspondiente, al valor de la
variable día. Si día toma un valor fuera del rango, escribir un mensaje de error.
Entero dia
inicio
Escriba “ Ingrese el numero del dia “
Lea dia
caso día
1:
Escriba "domingo"
2:
Escriba "Lunes"
.....................
7:
Escriba "sábado"
sino:
Escriba "error"
fin caso
fin
Para visualizar la ventaja de esta estructura dejamos propuesto como ejercicio la
implementación de este mismo ejemplo con estructuras si-entonces-sino-finsi anidadas.
Podemos graficar esta estructura de la siguiente forma donde Ai representa la acción
correspondiente al valor de la selección E:
21
ENTRADA
E1 E2 E3 De otro modo
A1 A2 A3 Acción B
6.7.3 Estructuras de Repetición

Se analizarán ahora las diferentes formas de describir la repetición de la ejecución de una
acción o de un conjunto de acciones.
6.7.3.1 Estructura Repita-hasta

Este esquema ya fue introducido antes, recordando el ejemplo de la distribución de caramelos,
en su algoritmo se tenía:
repita
t1.1 tomar un caramelo de la bolsa
t1.2 poner el caramelo en la caja correspondiente
hasta (t1.3) la bolsa esté vacía
En este esquema se pueden distinguir dos elementos importantes,
• Un conjunto de acciones S que se repiten, lo que se llama rango del ciclo, en el ejemplo
sería t1.1 y t1.2.
• La condición de fin de repetición, expresada bajo la forma de un predicado, (t1.3).
El formato de la estructura es:
repita
acción 1
acción 2
........ /* Acciones que forman el cuerpo del Repita*/
acción n
hasta ( condición de salida )
El predicado es evaluado después de cada ejecución de la secuencia y por lo tanto es
importante tener en cuenta que: Las acciones son ejecutadas, por lo menos una vez. La
representación gráfica de esta estructura es la siguiente:
22
ENTRADA
EJECUTA
ACCION
EVALUA Falso
CONDICION
Verdadero
SALIDA
Las acciones deberán repetirse en tanto, el predicado se mantenga falso. Este se evalúa
después de ejecutarse las acciones. Cuando el predicado resulta verdadero, se da por
finalizada la ejecución del lazo. Como las estructuras anteriores se considera la unidad con un
solo punto de entrada y una única salida.
Entre las características particulares de este esquema de repetición podemos citar las
siguientes:
• Entre el conjunto de acciones que forman el cuerpo de la estructura y que se repiten, debe
haber, al menos, una que esta relacionada con el predicado de tal manera que se pueda
modificar su valor, de lo contrario, las acciones se repetirán indefinidamente.
• El predicado es un predicado de salida, en él está expresada la condición que hace "salir",
al procesador de la iteración.
• En esta estructura de repetición, no es necesario conocer con anterioridad el número de
repeticiones que se van a llevar a cabo.
Analicemos un ejemplo donde se utilice esta estructura:
Enunciado:
Se deben escribir los dígitos de 0 a 9.
Método:
A partir de una variable entera, que inicialmente debe estar en cero, se ira realizando en cada
iteración la escritura del valor actual de la variable y su incremento, la salida del lazo se
produce cuando el valor alcanzado por la variable supere nueve.
entero digito
inicio
digito 0 /* Inicializa la variable*/
repita
Escriba digito
digito digito +1
hasta digito > 9 /* condición de salida del lazo*/
fin
23
6.7.3.2 Estructura Mientras-haga-fin mientras

Como se observó en el ejemplo de los caramelos descripto con anterioridad el esquema de
repetición "Repita-hasta" sólo era posible de aplicar en ese caso si se estaba seguro de que
la bolsa contuviese cuatro o más caramelos, es decir que por lo menos se ejecutarían una vez
las aciones del lazo.
La estructura "mientras-hacer-fin mientras" es del mismo tipo que la anterior, la diferencia
fundamental es que en ésta la condición o predicado se evalúa antes de ingresar a la
estructura de repetición.
El formato de la estructura es:
mientras ( condición para entrar o quedarse en el lazo) haga
acción 1
acción 2 /*Acciones que forman el cuerpo del mientras*/
....
acción n
fin mientras
Esta estructura como las anteriores se la considera como una unidad, que tiene un único
punto de entrada y una única salida.
ENTRADA
EJECUTA EVALUA F
ACCION CONDICION
SALIDA
En este esquema, el delimitador fin mientras indica el fin de la secuencia de acciones a repetir,
la cantidad de veces que se ejecutarán las acciones no es conocida con anterioridad. El
predicado de control es evaluado, antes de la ejecución de la secuencia de acciones que
forman el cuerpo del mientras. Si resulta verdadero la secuencia es ejecutada, si el predicado
resulta falso, se finaliza la repetición.
Analicemos el mismo ejemplo utilizado con la estructura Repita con esta nueva estructura de
repetición.
Enunciado:
Se deben escribir los dígitos de 0 a 9.
Método:
A partir de una variable entera, que inicialmente debe estar en cero, se ira realizando en cada
iteración la escritura del valor actual de la variable y su incremento, el ingreso para ejecutar las
acciones del lazo requiere que el valor de la variable sea menor o igual a nueve.
24
Entero digito
inicio
digito 0 /* Inicializa la variable*/
mientras digito < 10 haga /* condición de entrada al lazo*/
Escriba digito
digito digito +1
fin mientras
fin
Si comparamos este algoritmo con el utilizado en la estructura Repita, se observa que se
emplean las mismas acciones, la diferencia está dada en las condiciones, esto es así porque
en un caso la condición es para permanecer en el lazo ( Estructura Mientras ) y en el otro es
para salir Estructura Repita.
Ejemplo:
Dados dos números naturales que representan el dividendo y el divisor, el algoritmo debe
calcular el cociente y el resto con un procesador para el cual las únicas operaciones
aritméticas primitivas son la suma y la resta. Por lo tanto se deberá realizar la división
mediante restas sucesivas
Método:
Para efectuar la división entera, restamos el valor del divisor del dividendo, tantas veces como
sea posible. El cociente será la cantidad de restas efectuadas y el resto el resultado de la
última resta.
Variables Descripción
DVDO Variable de entrada, tipo numérico entero, cuyo valor representa el
dividendo.
DIV Variable de entrada, tipo numérico entero, cuyo valor representa el
divisor.
Q Variable de salida, tipo numérico entero, en la cual se calcula el
cociente.
R Variable de salida, tipo numérico entero, en la cual se almacena el
resto.
Algoritmo del cociente entero:
Entero DVDO, DIV, R,Q
inicio
Escriba “ Ingrese dividendo y divisor “
lea DVDO, DIV
R DVDO
Q 0
mientras R >= DIV haga
R R - DIV
Q Q+1
fin mientras
escriba "cociente", Q
escriba "resto", R
fin
25
6.7.3.3 Estructura Para-haga-fin para

Dado que en algunas aplicaciones, resulta útil, utilizar un conjunto de acciones que se
ejecutan, invariablemente, un número determinado de veces, cuando el número de
repeticiones es conocido de antemano, se plantea una nueva estructura de repetición,
denominada "para-haga-fin para"
para V Vi hasta Vf haga

acción 1
acción 2 /*Acciones que forman el cuerpo del Para*/
....
acción n
fin para
Donde:
V Es una variable tipo numérico llamada variable de control del lazo, o índice del lazo o
bucle
Vi, Vf son variables de tipo numérico, constantes de tipo numérico o expresiones aritméticas,
Vi Es el valor inicial de V
Vf El valor final a alcanzar por la variable de lazo
El conjunto de acciones es el rango de la estructura de repetición. En este esquema el
procesador es el encargado de actualizar la variable de control V desde su valor inicial Vi
hasta el final Vf con un incremento P, que en este caso será de uno.
El número de veces que se repite el ciclo será:
(V f − Vi + P )
P
Si este número resultara cero o negativo el ciclo no es ejecutable.
Es importante resaltar que en el entorno LPP no existe la posibilidad de utilizar incrementos
distintos de 1, y por lo tanto escribimos solamente:
Para V Vi hasta Vf haga.
La representación gráfica de esta estructura es la de la figura siguiente.
Al igual que las estructuras anteriores, se tiene una sola entrada y una sola salida. Para
comprender mejor esta estructura de repetición analizaremos su implementación con una
estructura mientras.
V Vi
mientras ( V <= Vf ) haga
acción 1
acción 2
………
V V+1
fin mientras
Al igual que las estructuras anteriores, se tiene una sola entrada y una sola salida. Para
comprender mejor esta estructura de repetición analizaremos su implementación con una
estructura mientras.
26
ENTRADA
V Vi
F
V <= Vf
EJECUTA
ACCION SALIDA
V V+P
V Vi
mientras ( V <= Vf ) haga
acción 1
acción 2
………
V V+1
fin mientras
El ejemplo de escribir los diez primeros dígitos utilizando la estructura para-hacer-fin-para
sería:
Entero digito
inicio
para digito 0 hasta 9 haga
Escriba digito
fin para
fin
Como se puede apreciar la implementación de la solución utilizando la estructura para, es mas
sencilla que las soluciones vistas anteriormente, esto se debe a que cuando se conoce el
número de repeticiones es conveniente el uso de la estructura para.
6.7.3.4 Ciclos Anidados

Así como dentro de una estructura de decisión se podía incluir otra estructura de decisión,
también es posible insertar un ciclo en el interior de otro, las leyes de anidamiento son
similares en ambos casos. La estructura interna debe estar totalmente incluida en la externa,
no pudiendo existir solapamiento.
27
Por cada valor que toma la variable de control del ciclo externo, deberá ejecutarse, totalmente
un ciclo interno.
La mayoría de los lenguajes de programación incluyen una sentencia de control que es la "ir
a" la cual obliga a una transferencia inmediata del control, a un punto predeterminado del
algoritmo, saltando por encima de las estructuras estudiadas. Esta sentencia ha sido y sigue
siendo objeto de discusiones, mientras algunos autores proponen su eliminación, otros,
permiten su uso como excepción, para casos extremos.
6.8 Estructuras de datos
6.8.1 Introducción
El manejo de datos no puede ser realizado siempre en forma cómoda y confiable mediante el
uso de variables simples (como las vistas hasta el momento), en muchos casos resulta casi
imposible utilizar este tipo de variables para almacenar y operar sobre ciertos conjuntos de
datos.
Al comienzo de esta unidad hemos introducido el concepto de dato que como se recordará
puede ser un número entero, un número real, un carácter o una constante lógica. El problema se
plantea cuando tenemos gran cantidad de datos que guardan entre si alguna relación. Para cada
uno de estos datos se debería utilizar una variable distinta, lo que ocasiona en la mayoría de los
casos complicaciones en el algoritmo a desarrollar, como también en la cantidad de variables a
utilizar.
Para resolver muchas de estas dificultades se agrupan los datos en un mismo conjunto, bajo un
nombre común, que se pueden tratar como una sola unidad. Estos conjuntos reciben el nombre
de Estructuras de Datos
Cuando nos encontramos resolviendo un problema en particular, se debe tratar que la
organización de sus datos se realice en forma estructurada; por lo tanto, seleccionar los datos,
adecuadamente, es un paso necesario y fundamental al definir y, posteriormente, resolver el
problema. Todas las formas posibles en que los datos primitivos se relacionan lógicamente,
definen distintas estructuras de datos.
! Un arreglo (array) es un conjunto de variables del mismo tipo, identificados por el mismo nombre
y que se distinguen entre sí por medio de un número que las ordena.
A cada elemento del arreglo se accede teniendo en cuenta la posición que ocupa dentro del
conjunto de datos.
Según el tipo de datos almacenados en el arreglo se los puede clasificar en:
• Numéricos ( enteros o reales )
• Alfanuméricos ( caracteres o string )
Según la cantidad de parámetros necesarios para dimensionar el arreglo, se pueden clasificar en
los siguientes tipos:
• Unidimensionales llamados vectores o listas
• Bidimensionales tipo matriz
• Multidimencionales
Para comprender la verdadera utilidad que se obtiene utilizando arreglos consideremos el
siguiente problema:
Enunciado:
28
“Una empresa recibe mensualmente información sobre las ventas de cada una de sus tres
sucursales y, desea obtener un listado de aquellas cuyas ventas superan el promedio de las
mismas.”
Método:
Para resolver este problema deberá leerse dos veces la información de cada sucursal, con la
primer lectura de datos se determinara el promedio de las ventas, y con la segunda se
determinará cual o cuales de las sucursales tienen ventas superiores al promedio.
Aplicando la técnica de refinamientos sucesivos, el algoritmo completo resulta:
entero I
real venta, promedio
Inicio
promedio 0
para I 1 hasta 3 haga
lea venta
promedio promedio + venta
finpara
promedio promedio / 3
lea venta
si venta >= promedio entonces
escriba I, venta
fin si
fin para
fin
Este algoritmo es ineficiente por el hecho de leer dos veces el mismo conjunto de datos. Una
forma alternativa de obtener los mismos resultados es definir tres variables numéricas, cuyos
valores, correspondan a las ventas de cada una de las sucursales. Para este caso el algoritmo
completo seria:
real venta1, venta2, venta3, promedio
inicio
lea venta1
lea venta2
lea venta3
promedio (venta1 + venta2 + venta3) / 3
si venta1 >= promedio entonces
escriba "1 ", venta1
fin si
fin si
fin si
fin
29
Se debe notar que este algoritmo es valido, solo, para tres sucursales. ¿Como se plantearía el
algoritmo para 100 sucursales? Utilizando el mismo enfoque que para el algoritmo anterior, se
deben definir 100 variables venta1, venta2, K , venta100.
real venta1, venta2, , venta100, promedio
inicio
lea venta1, venta2, , venta100
promedio (venta1+ venta2+…+… +venta100) / 100
escriba " 1 ", venta1
fin si
escriba " 2 " , venta2
fin si
….
….
escriba " 100 ", venta100
fin si
fin
Como se observa, se han utilizado los símbolos K , M . Al primero de ellos lo hemos utilizado para
denotar la lectura de las 100 variables y para calcular el promedio de las ventas y, el segundo,
para indicar que la comprobación de las muestras continúa desde la sucursal 3 hasta la 99.
Estos dos símbolos no son comprendidos por ningún procesador y la solución seria escribir
explícitamente las 100 variables y las 100 estructuras de decisión, lo cual es para nada eficiente.
Una forma más optimizada y adecuada para resolver este problema consiste en reunir las ventas
de las 100 sucursales bajo un único nombre, por ejemplo venta; venta que es un conjunto de
valores reales podría estar representada, esquemáticamente, en forma de tabla, como muestra
la siguiente figura:
1 2 3 4 ... 100
578 115 654 ... 121
120
Para individualizar a uno de los 100 valores se utiliza su ubicación en la tabla colocándola entre
corchetes [i], siendo i la posición a la cual se le denomina índice, de esta manera venta[3]
representa el tercer valor (115 que indica la venta de la tercera sucursal). Se define entonces un
arreglo lineal, tabla o vector, de nombre venta cuyos 100 elementos son venta[1], venta[2],...,
venta[100].
Ejemplo:
Supongamos el siguiente experimento relacionado con nuestra especialidad: Se deben
almacenar los valores de tensión sobre una determinada resistencia, los valores deben
medirse cada.1 segundo durante un determinado tiempo fijado por el operador; los datos
almacenados (entrada) deben procesarse, aplicando la siguiente expresión, para generar un
nuevo conjunto de datos (salida):
salida[ti] = entrada[ti] * 2.5 + entrada[ti - 1] * .25 para ti > .2 seg.
salida[1] = salida[2] = 0.0
30
Donde entrada[ti] y salida[ti], son los valores de tensión de entrada y salida correspondientes
al instante de tiempo ti. Se pide imprimir los valores de las tensiones de entrada y salida
correspondientes a todos los instantes de tiempo ti, en que se realizaron las mediciones.
Si quisiéramos resolver el problema anterior utilizando variables simples, nos sería difícil
determinar la cantidad de variables a declarar, el momento de corte de la adquisición de datos,
el armado de fórmulas, etc., lo que hace que los programas sean poco claros y para nada
estructurados.
En cambio, si utilizáramos un tipo de datos como el sugerido: salida[k], entrada[k], donde
salida y entrada son nombres de arreglos de datos y k un subíndice que nos dice a qué
elemento del arreglo nos referimos, podríamos armar la toma de datos dentro de un lazo, el
cual terminaría cuando se supere el tiempo determinado por el operador ( mientras k<
(tiempo/0.1) ), y del mismo modo podríamos luego implementar la función de filtrado en otro
lazo, utilizando un criterio similar.
Para hacer notar la diferencia de enfoques, se sugiere tratar de resolver el problema anterior
haciendo uso de variables simples, para un tiempo de 5 seg., y luego resolverlo utilizando
arreglos para cualquier tiempo menor a 100 seg.
6.8.2 Definición y Características de los Arreglos de Datos
6.8.2.1 Arreglos Unidimensionales

Definición:
Un arreglo unidimensional, también llamado “vector”, es un conjunto de variables que poseen el
mismo nombre y el mismo tipo, y que se diferencian entre sí por un subíndice Ej.: entrada[1],
entrada[2], etc. Cada una de estas variables subindicadas se denomina elemento.
Cada componente de un arreglo se denota, explícitamente, y se accede, directamente,
mencionando el nombre del arreglo seguido de una expresión encerrada entre corchetes, a la
que llamaremos índice del arreglo.
El número o cantidad de componentes se indica cuando se define el arreglo y queda, desde
entonces invariable, a este número lo llamaremos dimensión del arreglo. Por ejemplo, la
dimensión del, arreglo venta es de 100 elementos. A un arreglo lineal se lo denomina también
arreglo unidimensional.
Para entender esto es posible suponer que la zona de memoria donde está almacenado el
arreglo es como una serie de casilleros, uno al lado del otro; para colocar (o extraer) algo de un
casillero, se da la orden: coloque (o extraiga) eso del casillero determinado. Notar que para
diferenciar un casillero del otro sólo se debe especificar su ubicación, o sea, su índice, ya que el
nombre es común a todos los casilleros.
Los datos estructurados en un arreglo pueden accederse mediante el uso del índice
correspondiente a su posición, se puede modificar un dato de una determinada posición,
borrarse, operar con el, etc.; todas las operaciones y accesos que se pueden realizar sobre
variables simples están permitidos para cada elemento de un arreglo.
O sea, el arreglo es un conjunto formado por un número determinado de variables simples,
ordenado de forma tal que se puedan acceder mediante el uso de un índice; en el ejemplo de la
introducción, los elementos del arreglo son:
entrada[1], entrada[2],....,entrada[i], ......,entrada[n];
Donde n es la cantidad de elementos que forman el arreglo y además determina la longitud del
arreglo. El nombre del arreglo es entrada, y por lo tanto entrada[1] es el primer elemento del
arreglo y entrada[n] es el último.
Los elementos del arreglo están ordenados:
31
• entrada[i-1] precede a entrada[i] para i = 2, 3,....n

• entrada[i+1] sigue a entrada[i] para i = 1,....n-1
Son ejemplos de arreglos unidimensionales los siguientes:
• El conjunto de las notas de un parcial correspondientes a los alumnos de un curso.
• Los números de día del mes.
• La cantidad vendida por cada vendedor en un día.
• La edad de los concurrentes a un centro de salud, etc.
Como ejemplos de las operaciones más habituales que pueden realizarse sobre arreglos de este
tipo están las siguientes:
• Acceder al k-ésimo elemento para examinar su contenido.
• Acceder al k-ésimo elemento para modificar su contenido.
• Operar con el k-ésimo elemento del arreglo
• Ordenar los elementos de un arreglo según un determinado criterio.
• Explorar el arreglo en busca de los elementos del mismo que cumplan con determinada
condición.
Los arreglos se declaran según la siguiente sintaxis:
arreglo[ cantidad_de_elementos ] de tipo_de_dato nombre_de_la_variable
Por ejemplo:
arreglo[100] de entero notas
6.8.2.2 Implementación de Arreglos Unidimensionales

Veremos la implementación utilizando arreglos de los ejemplos descriptos anteriormente:
Ejemplo 1:
arreglo[100] de real venta
real, promedio
entero I
inicio
promedio 0
lea venta[ I ]
promedio promedio + venta[ I ]
fin para
promedio promedio / 100
si venta[ I ] >= promedio entonces
escriba “ La sucursal “, I, " ", venta [ I ]
fin si
fin para
fin
32
Ejemplo 2:
arreglo [500] de real entrada
arreglo [500] de real salida
real tiempo, reloj
entero ind, f
inicio
escriba "ingrese tiempo de toma de muestras en seg."
lea tiempo
f (tiempo / 0.1)
para ind 1 hasta f haga
lea entrada[ind]
fin para
salida[1] = 0
salida[2] = 0

salida[ind] entrada[ind] * 2.5 + entrada[ind - 1] * 0.25
finpara
escriba "SALIDA ENTRADA TIEMPO"

escriba salida[ind], " ", entrada[ind], " ", ind * 0.1
fin para
fin
Como se ve en las implementaciones, éstas son mucho más sencillas y ordenadas utilizando
arreglos de datos que con variables simples.
6.8.2.3 Arreglos Multidimensionales

Así como se han implementado arreglos unidimensionales en el ejemplo anterior, también
pueden implementarse arreglos multidimensionales (como matrices) del siguiente modo:
a[20][20] donde a es una matriz cuadrada de 20 por 20, o podría ser:
a[10][20][10] donde a es ahora un arreglo de tres dimensiones, de 10 por 20 por 10 elementos.
Las aplicaciones pueden ser en el álgebra matricial, así como para llevar distintos tipos de
información codificada en las distintas columnas o filas de la matriz.
A título ilustrativo, si en el ejemplo previo se desea almacenar también la corriente que circula
por la resistencia, podríamos definir un arreglo de 2 dimensiones con la misma cantidad de
elementos que el arreglo unidimensional (como si tuviéramos dos arreglos unidimensionales uno
al lado del otro, del mismo tipo que el empleado anteriormente para almacenar la tensión); a la
primera dimensión le asignamos la tarea de almacenar la tensión y a la segunda la de almacenar
la corriente.
6.8.3 Implementación de Arreglos Multidimensionales

Implementaremos el ejemplo descripto en 6.8.2.2:
33
arreglo [2,500] de real entrada, salida

real tiempo, reloj
entero ind, f
inicio
escriba "ingrese tiempo de toma de muestras en seg."
lea tiempo
f (tiempo / 0.1)
lea entrada[1][ind]
lea entrada[2][ind]
fin para
salida[1][1] = 0
salida[1][2] = 0
salida[2][1] = 0
salida[2][2] = 0
para ind 3 hasta f con paso 1 hacer
salida[1][ind] entrada[1][ind] * 2.5 + entrada[1][ind - 1] * 0.25
salida[2][ind] entrada[2][ind] * 2.5 + entrada[2][ind - 1] * 0.25
fin para
Escriba "SALIDA ENTRADA TIEMPO"
escriba salida[1][ind], entrada[1][ind]
escriba salida[2][ind], entrada[2][ind], ind * 0.1
fin para
fin
34
6.9 Guía de ejercicios
6.9.1 Ejercicios Resueltos

1- Diseñar un algoritmo para inflar una rueda de bicicleta con un inflador de mano con
manguera utilizando técnica de refinamientos sucesivos.
Ambiente
inflador c/manguera
rueda de bicicleta desinflada
Acciones primitivas
poner manguera
girar una vuelta la manguera a derecha o izquierda
accionar 5 veces el émbolo del inflador
Condiciones
manguera ajustada
manguera suelta
rueda inflada
2- Cambio de lamparita
Diseñar un algoritmo para cambiar una lamparita quemada de un artefacto suspendido del
techo. Utilizar la técnica de refinamiento sucesivo.
Ambiente:
-lamparita quemada.
-lamparita nueva.
-escalera.
Acciones primitivas.
-situar la escalera debajo del artefacto que tiene la lamparita quemada.
-subir un peldaño de la escalera.
-bajar un peldaño de la escalera.
-dar un giro a la lamparita.
-poner lamparita.
-sacar lamparita.
Condiciones:
-la mano alcanza la lamparita.
-llegar al piso.
-lamparita suelta.
-lamparita ajustada.
35
3- Los operarios de una empresa trabajan en dos turnos, uno diurno, cuyo código es menor
que 10 y otro nocturno, de código mayor o igual a 10.Se desea calcular el jornal para un
operario sabiendo que, para el turno nocturno, el pago es de 1.50 pesos la hora y, para el
turno diurno, es de 1.20 pesos la hora pero, en este último caso, si el día es domingo, se paga
un adicional de 0.80 pesos la hora.
Método
Se deben ingresar el código del turno, la cantidad de horas trabajadas y si el día es o no,
domingo.
Si el turno es nocturno, calcular el jornal con la fórmula correspondiente a dicho turno,
calcularlo con la fórmula correspondiente a turno diurno y, si el día es domingo, agregarle el
adicional.
Informar el resultado.
Las fórmulas con las cuales se debe calcular el jornal son:
1-Turno nocturno.
Jornal 1.50* horas trabajadas
2-Turno diurno.
a) si el día no es domingo.
Jornal 1.20 * horas trabajadas
b) si el día es domingo.
Jornal ( 1.20+0.80) * horas trabajadas
El algoritmo puede plantearse como sigue.
-Leer datos
-Calcular el jornal
-Informar resultados
Como las acciones de este algoritmo no son primitivas, aplicaremos la técnica de
refinamientos sucesivos.
Leer los valores correspondientes a las horas trabajadas, el código del turno y el día.
Si el turno es nocturno
entonces
calcular el jornal de acuerdo con la fórmula 1
sino
calcular el jornal de acuerdo con la fórmula 2
fin si
Escribir el valor del jornal
Como la acción "calcular el jornal de acuerdo con la FORMULA 2" no es primitiva, debemos
realizar un nuevo refinamiento.
Leer los valores correspondientes a las horas trabajadas, el código del turno y el día.
Si el turno es nocturno
36
entonces
calcular el jornal de acuerdo con la Formula 1.
sino
si el día no es domingo
entonces
calcular el jornal de acuerdo con la Formula 2a
sino
calcular el jornal de acuerdo con la Formula 2b
fin si
fin si
Escriba el valor del jornal.
fin
Como ahora, todas las acciones son primitivas, procedemos a escribir el ambiente del
algoritmo.
Ambiente del Algoritmo
Variables Descripción
HORAS Variable de entrada, de tipo numérico, cuyo valor es la cantidad de
horas trabajadas en un día, por un operario.
TURNO Variable de entrada, de tipo numérico entero, cuyo valor es el código
del turno.
DIA Variable de entrada, de tipo cadena, cuyo valor es el nombre del dia.
JORNAL Variable de salida, de tipo numérico real, que contiene el pago que
debe efectuarse
El algoritmo completo, resulta:
Entero TURNO, HORAS

Cadena[50] DIA
real JORNAL
Inicio
Lea HORAS, TURNO, DIA
si TURNO>=10
entonces
JORNAL 1.5 * HORAS
sino
si DIA <> "domingo"
entonces
JORNAL 1.2 * HORAS
sino
JORNAL 2.0 * HORAS
37
fin si
fin si
Escriba JORNAL
fin
4- Dadas las siguientes variables numéricas reales, expresarlos en notación de punto flotante
normalizado con la precisión indicada en cada caso.
a) X = 347.5 con precisión de dos dígitos significativos
La notación en punto flotante es una notación especial en la cual sólo se usa un cierto número
de dígitos de precisión seguidos por una potencia de diez adecuada. La notación en punto
flotante normalizado, consiste en colocar la primera cifra significativa después del punto
decimal. Dado un número, primero hay que determinar la precisión a utilizar y analizar si el
número deberá ser truncado o no. En el caso de que se deba truncar el número se debe
efectuar un redondeo sobre el último dígito de precisión sumándole uno en caso de que el
primer dígito descartado sea mayor que cinco. Luego hay que ajustar adecuadamente la
magnitud del número: por cada lugar decimal que se mueva hacia la izquierda, se suma uno a
la potencia de diez que se utiliza como multiplicador y por cada lugar que se mueve hacia la
derecha, se resta uno a dicha potencia. En este caso:
X = 347.5 con dos dígitos de precisión, será:
X = 0.35 * 103 (El primer dígito descartado es un 7, por lo tanto, se suma un 1 al 4. El

exponente 3 expresa el corrimiento del punto decimal tres lugares hacia la izquierda).
b) Y = 0.0003132 con precisión de tres dígitos significativos
Y = 0.313 * 10-3 (En este caso, al descartar el 2 no se modifica el último dígito de precisión. El
exponente -3 obedece a que el punto decimal fue trasladado tres lugares hacia la derecha.)
6.9.2 Ejercicios Propuestos

1- Indicar el tipo de cada una de las siguientes constantes.
-145 -145. -145.00 -145.01
2- Describir el procesador (acciones primitivas y condiciones) y el ambiente para desarrollar
algoritmos que resuelvan los siguientes problemas.
Calcular la media aritmética de tres números con una calculadora de bolsillo.
Buscar el rey de copas en un mazo de naipes.
De una sola tirada de cinco dados, informar si se forma generala, tomando de un dado por vez
y comparando de a dos dados.
De un mazo de cartas españolas se desean formar cuatro pilas, una para cada palo, teniendo
en cuenta que solo se puede mirar de una carta por vez.
De una pila de tarjetas numeradas, informar si están o noten orden ascendente, tomando de a
una tarjeta por vez y comparando de a dos números entre sí (no hay dos números iguales).
3- Hacer una clasificación de los diferentes tipos de datos y dar ejemplos de cada uno de
ellos.
4- Indicar el tipo de cada una de las siguientes constantes:
a) J = 517 d) V = 'F' g) A = -2.106 * 10-3
38
b) F = 517.0 e) H = F h) L = -615
c) K = '517.0' f) B = -420.0 i) E = 0.03
5-Dadas las siguientes variables reales, expresarlas en notación de punto flotante normalizado
con una precisión de tres dígitos significativos.
a) X = 84.58 d) A = 3417.6101 g) P = -6173.0

b) Y = 0.0001375 e) B = -0.40032 h) Q = 0.103
c) Z = 1.2 f) C = 0.012422 i) R = 0.12358
6- Escribir las siguientes expresiones con operadores aritméticos:
(X * Y )2
a) G = Respuesta: G = (( X * Y )^ 2 ) / ( X + Y )
X +Y
B+C
A+
A+B D
b) F = c) Y =
C−D E
F+G
A A 1
−1 −
d) Z = B e) X = B + C D2 − E
C F H
1+ +
D A 1+ Y
7- Evaluar las siguientes expresiones:
a) 5 * (7 + 3)/2 + 1
Las reglas que permiten evaluar una expresión aritmética pueden resumirse del siguiente
modo:
En primer lugar se resuelven las expresiones entre paréntesis antes de ser combinadas con
otras porciones de la expresión completa. En el caso de paréntesis dentro de paréntesis
primero se evalúa la subexpresión más interna.
Las operaciones aritméticas dentro de una expresión se ejecutan de acuerdo al orden de
precedencia ya expuesto en teoría
+ 3) / 2 + 1
5 * (7{
10
51210 / 2 + 1
*3
50
50
14/2
24+31
25
12+31
25
26
b) 4 + 7 * 2 - (3 - 4)^2
c) 2 + ((5 - (9/3)) * 2 + 4)
d) 2/(1/4 + 2/(1/4 + 2))
e) 4 + 2 * 3.0^2
f) (4 * 3/6 + 1/3) - 15/(3^2 - 6)
39
8- Dadas dos constantes numéricas enteras P=5 y Q=10 evaluar los siguientes predicados:
a) 3 * P < Q
1424
3
F
1<3
P210 Y Q
12=3
15
F F
b)
F
12Y3
F
F
c) P < 8 O Q >= 15
d) NO (P + 1 < 8 Y Q < 30)
e) 2 * Q <> 15 O 3 * P >= Q
f) P > 18 Y (Q < 50 Y Q >= 10)
g) 2 * P >= Q Y Q <= 3 * P
h) (Q > 2 * P O P * Q = 50) Y P + Q = 20
i) NO (10 * Q < 80 Y (20 * P <> 10 * Q O Q >= 10))
j) NO (NO (20 * P <= 150 O P < Q) O 30 * P > 200) Y Q = 15
9- Sean A, B y C variables numéricas; M y N variables cadena y R y S variables lógicas, cuyos
valores son:
A = 8 C = 10 N = “computadora” S=V
B = -2 M = “cómputo” R=F
Se pide evaluar los siguientes predicados:
a) (A < 4 Y R) Y (M < N O A = C)
b) NO (M < 'computación') O (B < A Y (NO(A <> 2) Y S))
c) NO ((B > 0 Y R) O (R O (S O (R Y N > “compra”))))
d) ((NO (NO S O R) Y (R O R)) O NO (NO S Y S)) O (S Y S)
10- Sean A, B, C y D variables numéricas, escribir los predicados correspondientes a los
siguientes enunciados:
a) Las variables A, C y D tienen el mismo valor.
Respuesta: En este caso se pueden escribir distintos predicados que cumplan con el
enunciado.
Por ejemplo:
A=C Y A=D
A=C Y C=D
A=D Y C=D
b) Los valores de B y C son superiores al valor de A.
c) Los valores de A y B son iguales pero difieren del valor de C.
d) El valor de A es superior al de B y está estrictamente comprendido entre los valores de C y
D.
e) El producto de A y B difiere en 5 de la suma de C y D.
f) Los valores de todas las variables son distintos entre sí y ninguno de ellos es mayor que 10.
40

UNIDAD6

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

UNIDAD6

Cargado por

Copyright:

Formatos disponibles

DEPARTAMENTO DE ELECTRONICA

6 Programación Estructurada ................................................................................. 1

6.1 Introducción a la Programación

6.2 Resolución de Problemas

6.2.1 Etapas en la Resolución de Problemas.

1. Descomponer la subtarea t1.2 del ejemplo anterior.

6.3 Procesador, Ambiente, Acción y Condición

! Es el conjunto de recursos y consideraciones necesarias para la ejecución de una tarea. Si el

6.3.4 Técnica de Refinamientos sucesivos

Figura 6.1 - Técnica de refinamientos sucesivos

6.3.7 La Programación Estructurada como Herramienta de Diseño

Ésta es la noción clásica de lo que se entiende por programación estructurada (llamada

Fig. 5.1. Diseño descendente.

6.4 El computador como Procesador

6.4.1 Constantes y Variables

6.4.2 Tipo Numérico

6.4.2.1 Tipos Numéricos Enteros

6.4.2.2 Tipo Numérico Real

6.4.2.3 Tipo Lógico (Booleano)

6.4.2.4 Tipo Carácter

6.4.2.5 Tipo Cadena de Caracteres

6.5.1 Expresiones Aritméticas

mod Resto de la división entera

div División entera

Paréntesis para agrupar

Orden Operador Significado

Estas funciones no Nombre de Significado

6.5.2 Expresiones Relacionales

<= Menor o igual

>= Mayor o igual

También es posible la comparación entre cadenas de caracteres, en este caso la comparación

6.5.3 Expresiones Lógicas

Operador Lógico Operador Lógico Significado

Y AND Conjunción o Producto Lógico

Operador Lógico Operador Lógico Significado

O OR Disyunción Inclusiva o Suma Lógica

NO y NE no están NO NOT Negación

Suma Lógica Negación Lógica

El orden de precedencia de los operadores lógicos es:

6.5.4 Expresiones Cadena de Caracteres

6.6 Asignación de Variables

6.6.1 Asignación Aritmética

6.6.2 Asignación Lógica

6.6.3 Asignación Carácter

6.6.4 Asignación Cadena de Caracteres

6.6.5 Entrada de Datos

6.6.6 Salida de Datos

6.7 Estructuras de Control

6.7.1 Estructuras de Decisión

6.7.1.1 Estructura si-fin si

EJECUTA ACCIONES EJECUTA ACCIONES

Un caso particular de esta estructura ocurre si no existen acciones a ejecutar cuando la

6.7.1.2 Anidamiento de Estructuras de Decisión

6.7.2 Estructuras de Decisión Generalizadas

6.7.3 Estructuras de Repetición

6.7.3.1 Estructura Repita-hasta

6.7.3.2 Estructura Mientras-haga-fin mientras

6.7.3.3 Estructura Para-haga-fin para

para V Vi hasta Vf haga

6.7.3.4 Ciclos Anidados

6.8 Estructuras de datos

6.8.2 Definición y Características de los Arreglos de Datos

6.8.2.1 Arreglos Unidimensionales