Академический Документы
Профессиональный Документы
Культура Документы
Programación Estructurada
Las computadoras digitales aun las más modernas y complejas, pueden ser vistas como un
gran conjunto de piezas. De una manera simple cada una de estas piezas representa
información en forma de conjuntos de bits, cada bit (dígito binario) puede estar en una de
dos posiciones o dicho de otra manera puede tener cualquiera de dos valores 0 ó 1.
Cualquier computadora tiene un conjunto muy reducido de operaciones triviales que puede
realizar, como son: corrimientos, comparaciones, sumas, etc., pero entonces, ¿cuál es la
distancia entre las operaciones triviales con bits y las increíbles hazañas que realizan las
computadoras?
Suponga que una persona desea comer su pastel favorito. Para solucionar este problema,
conviene dividirlo en pequeños subproblemas entre los que podrían encuentrarse:
conseguir la receta, obtener los ingredientes, elaborar el pastel, obtener compañía y
comerlo. Dependiendo del tamaño de cada uno de estos ‘pequeños subproblemas’ se
requerirá o no dividirlo en más subproblemas. Por ejemplo, conseguir la receta podría ser
resuelto de una manera simple si ésta se encuentra accesible en un librero al cual se tiene
acceso fácilmente, pero podría suceder que es una receta secreta y para conseguirla se
tiene que hacer un largo viaje a tierras extrañas, entrar a un castillo encantado, y
convencer a una bruja que la entregue.
Considere a la cocina (o a una computadora), que por si sola no puede realizar pasteles (ni
lograr cosas tan fascinantes como las que se mencionaron). Se puede observar también
que este 'hardware' (i.e., la cocina) tiene un conjunto muy limitado de 'operaciones' como
son batir, abrir la puerta del horno, medir tiempo y cantidades, que directamente tampoco
pueden hacer pasteles.
Como se sabe el proceso de cocinar pasteles (salida) es algo más complejo que se realiza
de ingredientes (entradas del proceso), de acuerdo a una receta (algoritmo), con ayuda de
utensilios, horno, cocinero, etc., (hardware).
fig.1 Proceso y algoritmo para crear un pastel
De esta forma puede considerarse a las recetas como objetos mágicos que sirven para
convertir los ingredientes en pasteles con ayuda de las habilidades del hardware de la
cocina.
Las instrucciones elementales de una receta deben ser realizadas a la medida de las
capacidades del hardware y también deben ser apropiadas para el nivel de comprensión
del lector potencial o usuario del algoritmo. Estas acciones básicas deben ser precisas, no
ambiguas y tomar una cantidad acotada de tiempo.
2
Consideraciones acerca de los algoritmos:
1. ¿Es correcto?
2. ¿Qué tan bueno es el resultado producido?
3. ¿Cuál es el ‘costo’ de la ejecución?
El azúcar, la harina, los huevos, etc., son los objetos manipulados por nuestra receta.
Como podemos observar estos elementos no solo constituyen las entradas y salidas del
algoritmo, sino también son construidos y usados durante su ejecución. Los algoritmos
generalmente operan sobre datos, pero estos no son masas amorfas de información sino
que involucran importantes relaciones entre sus datos.
3
• Talento
• Creatividad
• Inteligencia
• Lógica
• Experiencia
• Habilidad para construir y analizar abstracciones
Esta evolución de la tecnología del software puede verse representada por una estructura
de capas, en donde cada una de las capas continua siendo funcional.
Las formas que se han utilizado para tratar la complejidad de los sistemas son:
• Procedimientos
• Módulos
• Objetos
Tiene sus orígenes en la simulación, de hecho el primer lenguaje orientado a objetos fue
Simula, esto se debe a que en simulación generalmente se modela una aplicación como un
conjunto de entidades.
4
El lenguaje que se utiliza influye directamente la forma en que puede realizarse la
abstracción del mundo, y es a través de esta abstracción lo que permite resolver el
problema deseado.
Ejemplo: Inuiktitut el lenguaje de los Inuits tiene varias palabras para distintos tipos de
nieve –wet, fluffly, heavi, ici y otros. Por su propio lenguaje los inuits tienden a ser más
perceptivos a la nieve que los que viven en climas templados. Aunque no existan
diferencias entre los ojos de unos y de otros.
El primer principio para resolver un problema en forma orientada a objetos es: siempre
que se necesita realizar alguna tarea, lo primero que hay que hacer es encontrar un objeto
que lo realice.
Un objeto es diferente a una variable, ya que las variables por lo general solamente
permiten representar la estructura de datos de un objeto y no su comportamiento.
Las áreas de memoria no sólo sirven para almacenar datos sino también código en forma
de procedimientos ejecutables.
Una clase es un concepto que nos permite describir un conjunto de objetos similares.
5
Todos los objetos son instancias de una clase. El método invocado por un objeto en
respuesta a un mensaje está determinado por la clase del receptor. Todos los objetos de
una clase dada utilizan el mismo método en respuesta a mensajes similares.
Las tres propiedades principales que caracterizan a un lenguaje orientado a objetos son:
Herencia
Las clases pueden organizarse en una estructura jerárquica de herencias. Una subclase
hereda los atributos de una superclase del árbol. Una superclase abstracta es una clase
que es utilizada solo para crear subclases en las cuales no hay instancias directas.
Los componentes del software reusable permiten al programador tratar con problemas en
un nivel de abstracción superior.
6
Polimorfismo
Ventajas:
clase nombre
{
principal
comienza
enunciados
termina
}
<letra> <letra|dígito|$|_>*
Un enunciado en su forma más simple permite que una variable almacene un valor
especifico ya sea que se exprese explícitamente o a través de una operación.
Si se desea que una variable "a" contenga el valor de 5, se expresa explícitamente como:
a 5
7
Tipos de datos primitivos y expresiones
Las operaciones que pueden realizarse dependen del tipo de dato. Para los tipos de datos
numéricos son:
Las prioridades se alteran con el uso de paréntesis. Cuando existen operadores con la
misma prioridad entonces se aplica la regla de asociatividad de izquierda a derecha.
Operación Símbolo
AND &
OR |
NOT ¬
Ejemplo:
/**
*Suma el entero 5 y el entero 7
**/
class Suma5y7
{
principal
comienza
int a 5 //en la variable a se almacena el valor de 5
int b 7 //en la variable b se almacena el valor de 7
int c a + b //en c se almacena la suma de a con b
termina
}
8
Sin embargo, el algoritmo anterior carece de algo muy importante la comunicación
con el usuario, dicho de otra forma el resultado de la suma no se muestra.
lee nombreVariable
escribe nombreVariable
/**
* Da los buenos días al usuario a través de la pantalla
**/
class Saludo
{
principal
comienza
escribe “buenos días”
termina
}
Ejemplos:
/**
* Suma dos enteros proporcionados por el usuario, el resultado lo
* imprime en pantalla
**/
clase suma2Enteros
9
{
principal
comienza
int a, b, c
escribe “De un valor entero”
lee a
escribe “de otro valor entero”
lee b
c a + b
escribe “La suma de”
escribe a
escribe “con”
escribe b
escribe “es”
escribe c
termina
}
/**
* Suma dos enteros proporcionados por el usuario, el resultado lo
* imprime en pantalla. Versión más compacta que la clase anterior
**/
clase suma2Enteros
{
principal
comienza
int a, b, c
escribe “De un valor entero”
lee a
escribe “de otro valor entero”
lee b
c a + b
escribe “La suma de” + a + “con” + b + “es” + c
termina
}
/**
* Calcula el IVA de un producto. El usuario deberá proporcionar el
valor * del producto
**/
class CalculaIVA
{
principal
comienza
real precio, iva
escribe “Dame el valor del producto”
lee precio
iva precio * 0.15
escribe “El IVA de un producto de $“ + precio + “ es “ + iva
termina
10
}
/**
* Calcula el IVA de un producto. El usuario deberá proporcionar el
valor * del producto. Se utiliza una constante entera
**/
class CalculaIVA
{
principal
comienza
const int costoIVA 0.15
real precio, iva
escribe “Dame el valor del producto”
lee precio
iva precio * costoIVA
escribe “El IVA de un producto de $“ + precio + “ es “ + iva
termina
}
/**
* Calcula el IVA y el costo total de un producto. El usuario deberá
* proporcionar el valor del producto. Se utiliza una constante
**/
class CalculaIVA
{
principal
comienza
const int costoIVA 0.15
real precio, iva, costo
escribe “Dame el valor del producto”
lee precio
iva precio * costoIVA
total precio + iva
escribe “El IVA de un producto de $“ + precio + “ es “ + iva
escribe “y su costo total es de $ “ + total
termina
}
11
Salidas: costo
/**
* Calcula la cuota de peaje que deberá pagar un camión con base
* a su peso
**/
class peaje
{
principal
comienza
const real costoEje 5
const real costoTonelada 10
int numEjes, numToneladas
escribe “Proporcione el número de ejes del camión”
lee numEjes
escribe “¿Cuántas toneladas son?”
lee numToneladas
costo numEjes * costoEje + numToneladas * costoTonelada
escribe “El peaje del camión es de $” + costo
termina
}
Algunas reglas:
12
basada en una expresión booleana (aquella que al ser evaluada produce un valor
de verdadero o un valor de falso).
• para
• mientras
• repite
Estructuras de control
Secuenciación
e1
e2
Ejemplos de secuenciación:
Todos los ejemplos que se han visto hasta ahorita son de secuenciación.
/**
* Calcula el círculo y la circunferencia dado el radio
**/
clase Circulo
{
principal
comienza
const pi 3.1416
real radio, area, circunferencia
escribe “Proporcione el radio del circulo”
lee radio
area pi * radio ^ 2
circunferencia 2 * pi * radio
escribe “Un círculo con radio “ + radio
escribe “tiene area de “ + area
escribe “y una circunferencia de “ + circunferencia + “unidades”
termina
}
13
2. Intercambiar los valores de dos variables tipo carácter
/**
* Intercambia los valores de dos variables proporcionadas por el
usuario
**/
clase Intercambia
{
principal
comienza
char valor1, valor2, temp
escribe “Proporcione el primer carácter”
lee valor1
escribe “Proporcione el segundo carácter”
lee valor2
temp valor1
valor1 valor2
valor2 temp
escribe “Ahora el primer carácter vale” + valor1
escribe “y el segundo vale “ + valor2
termina
}
Selección
si c1
e1
si c1
e1
otro
e2
e1
e2
si c1
e3
e4
e5
14
e1
e2
si c1
e3
otro
e4
e5
e6
Expresiones booleanas:
Símbolo Significado
= igual
<> desigual
< menor
<= menor o igual
> mayor
>= mayor o igual
int a 5
int b 10
Expresión Valor
a=b falso
a <> b verdadero
a<b verdadero
a <= b verdadero
a>b falso
15
a >= b falso
(a = b) & ( a < b)
Ejemplos de selección:
clase SiempreJoven
{
principal
comienza
const int joven 21 //Declaración de la constante joven
int edad
escribe “Proporcione su edad”
lee edad
si edad < joven
escribe “La juventud es un tesoro divino, disfrútala”
escribe “La edad es un estado mental”
termina
}
/**
* Determina el mayor de dos enteros
**/
clase MayorDeDosNumeros
{
principal
comienza
int a, b, mayor
escribe “Dame dos números”
lee a, b
si a > b
mayor a
otro
mayor b
escribe “El mayor entre “ + a + “ y “ + b + “es: “ + mayor
termina
}
16
2. Encontrar el menor de 3 números enteros
/**
* Determina el menor de tres números enteros
**/
clase MenorDeTresNumeros
//versión 1
//La idea es determinar el menor de dos números y después comparar ese
//resultado con el tercer número
{
principal
comienza
int a, b, c, menor, menor1
escribe “Dame tres números”
lee a, b, c
si a < b
menor1 a
otro
menor1 b
si menor1 < c
menor menor1
otro
menor c
escribe “El menor entre “ + a + “ + “ + b + “ y “, c,
escribe “es: “ + menor
termina
}
/**
* Determina el menor de tres números enteros
**/
clase MenorDeTresNumeros
//versión 2
principal
comienza
int a, b, c, menor
escribe “Dame tres números”
lee a, b, c
si a < b entonces
si a < c
menor a
otro
menor c
otro // b < a
si b < c
menor b
otro
menor c
escribe “El menor entre “ , a, “ , “, b, “ y “, c, “es: “, menor
termina
}
/**
* Determina el menor de tres números enteros
**/
clase MenorDeTresNumeros
//versión 3
comienza
int a, b, c, menor
escribe “Dame tres números”
lee a, b, c
17
si a < b & a < c
menor a
otro
si a < b & a > c
menor c
otro
si a > b & b < c
menor b
otro
menor c
escribe “El menor entre “ , a, “ , “, b, “ y “, c, “es: “, menor
termina
}
/**
* Determina el menor de tres números enteros
**/
clase MenorDeTresNumeros
//versión 4
principal
comienza
int a, b, c, menor
escribe “Dame tres números”
lee a, b, c
Menor a
si b < menor
menor b
si c < menor
menor c
escribe “El menor entre “ , a, “ , “, b, “ y “, c, “es: “, menor
termina
}
/**
* Determina si se forma un triángulo
**/
clase triangulo
{
principal
comienza
int a, b, c
escribe “Favor de dar 3 números en orden”
lee a, b, c
si (a*a + b*b = c*c)
escribe “Los lados si forman un triángulo rectángulo”
otro
escribe “Esos datos no describen un triángulo”
termina
}
/**
* Determina si se forma un triángulo
**/
clase Pitágoras
{
principal
18
comienza
int a, b, c
escribe “Favor de dar 3 números en orden”
lee a, b, c
escribe a + “ , “ + b + “ y “ + c
si ¬ (a*a + b*b = c*c)
escribe “ no ”
escribe “forman un triángulo rectángulo”
termina
}
/**
* Determina el salario de un trabajador
**/
clase Salario
{
principal
comienza
const real costoHora 17.5
const real sobrePago 1.5
int numHoras
escribe “Proporciona el número de horas trabajadas”
lee numHoras
si numHoras <= 8
paga numHoras * costoHora
otro
paga 8 * costoHora + (numHoras-8) * sobrePago * costoHora
escribe “El salario correspondiente a “ + numHoras + “ es “ + paga
termina
}
10 - 8.5 M
8.4 – 7.0 B
6.9 – 6.0 S
5.9 – 0.0 N
/**
* Determina la calificación alfabética dada la calificación numérica
**/
clase Equivalencia
{
comienza
real califNumerica
char califAlfabetica
19
escribe “Proporcione la calificación final”
lee califNumerica
si califNumerica <= 10 & califNumerica >= 8.5
califAlfabetica ‘M’
otro si califNumerica <= 8.4 & califNumerica >= 7.0
califAlfabetica ‘B’
otro si califNumerica <= 6.9 & califNumerica >= 6.0
califAlfabetica ‘S’
otro
califAlfabetica ‘N’
escribe califNumerica + “ es equivalente a “ + califAlfabetica
termina
}
Iteración
• para
• mientras
• repite
para
El para permite escribir una iteración que se realizará de acuerdo al valor inicial de
una variable y hasta que dicha variable alcance un valor final.
Ejemplos:
/**
* Imprime los números del 1 al 100
**/
clase Imprime1-100
{
principal
comienza
para i 1 hasta 100, 1
escribe i
termina
}
/**
20
* Determina la suma de los números del 0 al 100
**/
clase Suma
{
principal
comienza
int suma 0
para i 0 hasta 100
suma suma + i
escribe "La suma entre 1 y 100 es " + suma
termina
}
/**
* Imprime los pares comprendidos entre 1 y 100
**/
clase ImprimePares1-100
{
principal
comienza
para i 1 hasta 100
si i mod 2 = 0 entonces
escribe i
termina
}
Otra versión:
/**
* Imprime los pares comprendidos entre 1 y 100
**/
clase ImprimePares1-100
{
//En esta versión el para inicia con el primer para
//y se incrementa de dos en dos
principal
comienza
para i 2 hasta 100, 2
escribe i
termina
}
/**
* Imprime los números múltiplos de 5 comprendidos entre un
* límite inferior y un límite superior
**/
clase ImprimeMultiplos5
{
principal
comienza
int limInf, limSup
21
escribe “Proporcione el límite inferior y el límite superior”
lee limInf, limSup
para i limInf hasta limSup
si i mod 5 = 0 entonces
escribe i
termina
}
/**
* Imprime las tablas de multiplicar del 0 al 10
**/
clase TablasMultiplicar
{
principal
comienza
para i 0 hasta 10
para j 1 hasta 10
escribe i + “*” + j + “=” + i*j
termina
}
/**
* Determina el factorial de un número proporcionado por el usuario
**/
clase Factorial
{
principal
comienza
int n, fact
escribe “Dame un número”
lee n
fact 1
para i 1 hasta n
fact fact * i
escribe “El factorial de “ + n + “ es “ + fact
termina
}
03 = 0
13 = 1
23 = 8=1+7
33 = 27 = 8 + 19 = 8 + (7 + 12)
43 = 64 = 27 + 37 = 27 + (19 + 18)
53 = 125 = 64 + 61 = 64 + (37+24)
63 = 216 = 125 + 91 = 125 + (61 + 30)
73 = 343 = 216 + 127 = 216 + (91 + 36)
clase AdaCubo
{
22
principal
comienza
int result 0, prim 1
escribe “Dame un número”
lee n
para i 1,n
comienza
result +=prim
prim += 6*i
termina
escribe n + “al cubo es:“ + result
termina
}
Bloques de enunciados
z2 = x2 + y2
/**
* Imprime los cuadrados perfectos entre 0 y 50
**/
clase CuadradosPerfectos
{
principal
comienza
int x, y, z
escribe “Los cuadrados perfectos entre 0 y 50 son”
para x 0 hasta 50
para y 0 hasta 50
comienza
z (x^2 + y^2)^(1/2)
si (z <= 50) & (z^2 = x^2 + y^2) entonces
escribe “x = “, x, “ y = “, y, “ z = “, z
termina
termina
}
mientras
mientras c1
e1
23
en donde e1 se ejecutara mientras la condición c1 sea verdadera.
Ejemplos:
/**
* Imprime los números entre 1 y 100
**/
clase Imprime1-100
{
//versión mientras
principal
comienza
int i 1
mientras i <= 100
comienza
escribe i
i++
termina
termina
}
/**
* Determina si un número dado es primo o no
**/
clase DeterminaPrimo
{
principal
comienza
int num
escribe “Escribe un numero”
lee num
int i 2
mientras num mod i <> 0 & i < num
i++
si i = num entonces
escribe num + “ es un número primo”
otro
escribe num + “ no es primo”
termina
}
repite
repite
e1
mientras c1
24
donde el enunciado e1 se ejecuta y después se evalúa la condición c1, si la
condición es verdadera el flujo de control se pondrá al inicio del repite es decir se
ejecutará nuevamente el enunciado e1 y si es falso terminara.
Ejemplos:
/**
* Imprime los números comprendidos entre 1 y 100
**/
clase Imprime1-100
{
//versión repite
principal
comienza
int i 1
repite
escribe i
i++
mientras i <= 100
termina
}
/**
* Invierte los dígitos de un entero
**/
clase InvierteEntero
{
principal
comienza
int num
escribe “Escribe un entero”
lee num
repite
escribe num mod 10
num num div 10
mientras num != 0
termina
}
/**
* Invierte los dígitos de los enteros dados por el usuario
* Pregunta al usuario si desea continuar
**/
clase InvierteMuchosEnteros
{
principal
comienza
int num
char deseo //Sirve para leer la entrada del usuario
repite
escribe “Escribe un entero”
25
lee num
repite
escribe num mod 10
num num div 10
mientras num != 0
escribe “Deseas continuar (s/n)?”
lee deseo
mientras deseo <> ‘n’
termina
}
Ejercicios:
Considere que:
int i 6
int j 9
a)
si i < j entonces
escribe “hola”
b)
si i < j/2 entonces
escribe “hola”
c)
si i < j entonces
escribe “hola”
si j > 7 entonces
escribe “adios”
otro
escribe “que tal”
a)
para i 1 hasta 10, 1
26
escribe i
b)
para i 1 hasta 10*2, 1
escribe i
c)
para i 10 hasta 1, -1
escribe i
d)
para i -2 hasta 10
escribe i
e)
int i 1
repite
escribe i
i++
mientras i < 10
f)
int i 10
repite
i--
escribe i
mientras i < 10
g)
int i 1
mientras i <= 10
comienza
escribe “hola”
i++
termina
h)
int i 1
mientras i > 10
escribe “El país de nunca jamás”
i)
int i 20
mientras i > 10
escribe “El país de nunca jamás”
27
7. Escribir un algoritmo para sumarlos números pares entre 1 y 100
8. Escribir un algoritmo que calcule el promedio de los números pares pares entre
1 y 100
9. Escribir un algoritmo para calcular el promedio de pares entre un límite inferior
y un límite superior
Ventajas de la modularidad:
Contrucción
Depuraci´n
Fácil de leer
Fácil de modificar
Eliminación de código redundante
Desarrollo independiente de módulos
Estilo:
28
breve descripción de los algoritmos y estructuras de datos globales
descripción de cómo usar el programa
descripción de variables globales
comentarios acerca de que tipo de datos espera el programa
Miniencabezado en cada módulo similar al del programa
Comentarios en el cuerpo de cada módulo explicando lo importante y confuso del
programa
Documentación general:
29