ALGBO - S6 Curso-01 Algoritmo Estructurado Basico - Metodologia de La Programacion.

Clases en Línea: Metodología de la Programación
Universidad Nacional de Ingeniería - FIIS

Facultad de Ingeniería Industrial y Sistemas
Curso I : Algoritmos & Estructura de Datos

CONTENIDO.
Metodología de la Programación.
1.- Método: Programación Estructurada.
2.1. Patrones: Secuencial - Selectivo - Repetitivo.
2.2. Técnicas: Sustitución - Apilamiento - Anidamiento.
2.- Método: Programación Modular (Procedimental)

2.1. Patrones: Subrutinas tipo Procedimiento - Subrutinas tipo Función
2.2. Técnicas: Abstracción - Encapsulamiento - Polimorfismo.
Bases Teóricas:
2. Método: Programación Estructurada.
Principios
● Principio de estructuración.
● Principio de continuidad.
2.1. Patrones o estereotipos.
● Secuencial
● Selectivo
● Repetitivo
Modelo de desarrollo: Semántica y sintaxis.

Análisis & Diseño. (A/DOO)
ENUNCIADO. (Problema de Dominio)
Paso 1. Análisis.
a. Definición de procesos.
i. Descripción de elementos
ii. Establecer reglas de negocio
b. Especificación de E/S
Paso 2. Diseño.
a. Algoritmos
i. Especificación Pseudocodigo UPSAM v.2.0
ii. Especificacion UML (Activity Diagram)
Paso 2. Implementacion.
● Pruebas y Depuración
a. Lenguaje C++ ANSI/ISO v.11
Jorge Medianero Acosta. Pag. 1

Ing. de Sistemas y Cómputo.
Aula: lista de alumnos:

Apellidos Nombre correo Gmail
--------------------------------------------------------------------------------------------------------------------------
1.Prado Oré, Augusto Gerardo [email protected] 10

2.FLORES CANDELA, [email protected] 3
3.IZAGUIRRE BARBARAN, Romel Carlof [email protected] 7
4.JÁUREGUI ZANABRIA, [email protected] 8
5. P.rìncipe Osorio, Fabricio Noske [email protected] 11
6.Ascurra Risco, Katherine Alejandra [email protected] 2
7.Guerrero Pichén, Alejandro Eduardo [email protected] 6
8.Príncipe Osorio, Fabiana [email protected] 12
9.Linares Choque Libia [email protected]
10.Villegas Peña, Victor Milton [email protected]
11.
------------------------------------------------------------------------------------------------------------------------
ALGBO-S6 Dom04Oct2020 1ra. sesion (04-Oct-2020)

Algoritmos: Análisis, Diseño e Implementación

a. Método: Programación Estructurada. [ Nota Adjunta-1 ]
1. Patrones: Secuencial-Selectivo-Repetitivo.
2. Técnicas: Sustitución-Apilamiento-Anidamiento.
Patrón secuencial: Taller de Diseño de algoritmos..
Modelo de clase.
Enunciado.
1. Análisis.
Definición del proceso(s)
- Descripción de sus elementos
Especificaciones de E/S
Entradas:
Salidas :
2. Diseño: de Algoritmos
a. Especificación Pseudocódigo
Algoritmo. nombre_identificador
var
//seccion de declaraciones
inicio
//entradas por consola
//proceso
//salidas por consola

fin
b. Especificacion UML (Activity Diagram).
3. Implementacion: Comprobación del algoritmo.

a. Lenguaje C++ v.11 ANSI/ISO.
b. Lenguaje Javascript.
c. Lenguaje Python v3.
4. Modelo de Pruebas: Test Unit (Pruebas unitarias)

Enunciado 1. Implementar una aplicación que calcule el área del círculo geométrico.
1. Análisis.
El área del círculo se obtiene mediante la siguiente expresión:
Proceso:
A=π . r ❑2❑ area <- PI * radio^2
En donde:
A es el área del círculo.
π es la constante PI = 3.141592
r es el radio
Entradas: Valor del radio, de tipo real
Salidas : area del circulo, de tipo real
2. Diseño del Algoritmo.

a. Especificación Pseudocódigo. [ Nota Adjunta-2 ]
Algoritmo. Area circulo v1

var
const PI <- 3.141592
real: radio, area
inicio
//entrada consola
escribir("Ingrese radio: ")
leer(radio)
//proceso
area <- PI * radio^2 // asignar <- :=
//salida consola
escribir("Area circulo: ", area)
fin.
3. Implementacion. (Comprobar algoritmo)

a. Lenguaje C++ v.11. [ Nota de escarga-1 ]

//Algoritmo. Area circulo v1

#include <cstdlib>
#include <iostream>
#include <cmath>
using namespace std;
int main( int argc, char *argv[] ){

//var
const float PI = 3.141592;
float radio, area;
//inicio
//entrada consola
printf("Ingrese radio: ");
scanf("%f", &radio);
//proceso
area = PI * pow(radio,2); // asignar <- :=
//salida consola
printf("Area circulo: %f", area);
return EXIT_SUCCESS;
}//fin.
/*
c++ v11
- compilado
- estricto, estatico
- fuertemente tipado.
*/
b. Lenguaje JavaScript
var
radio, area;
const PI = 3.141592;
//inicio
//entrada consola
radio = prompt("Ingrese radio: ");
//proceso
area = PI * Math.pow(radio,2);
//salida consola
console.log("Area circulo: ", area);
//fin

/*
Lenguaje JavaScript
- interpretado
- dinamico
- debilmente tipado
*/
c. Lenguaje Python
#Algoritmo. Area circulo v1
#var
PI = 3.141592
#real: radio, area
#inicio
#entrada consola
radio = float(input("Ingrese radio: "))
#proceso
area = PI * pow(radio,2) # asignar <- :=
#salida consola
print("Area circulo: ", area)
#fin.
# comentario de linea
'''
Lenguaje Python
- interperetado
- dinamico
- fuertemente tipado
'''
4. Test de prueba: (Prueba Unitaria) [ Nota Adjunta-3 ]

a. Lenguaje C++ v.11.
Valor conocido ,para obtener un resultado predecible
Taller de Diseño:
Proyecto colaborativo - Patrón secuencial [ Nota Adjunta-4 ]
Info sobre: OMG / UML [ Nota Adjunta 5 ]
[ Nota de Descarga-2 ]
Respuestas de los ejercicios propuestos: al correo: [email protected]
Sesion 02


--------------------------------------------------------------------------------------------------------------------------
1.Prado Oré, Augusto Gerardo [email protected]

2.FLORES CANDELA, Cristhian [email protected]
3.IZAGUIRRE BARBARAN, Romel Carlof [email protected]
4.JÁUREGUI ZANABRIA, Brenda [email protected]

5. P.rìncipe Osorio, Fabricio Noske [email protected]
6.Ascurra Risco, Katherine Alejandra [email protected]
7.Guerrero Pichén, Alejandro Eduardo [email protected]
8.Príncipe Osorio, Fabiana [email protected]
10. Villegas Peña, Victor Milton [email protected]
11. Romel Carlof IZAGUIRRE BARABARAN
------------------------------------------------------------------------------------------------------------------------
ALGBO-S6 Dom04Oct2020 2da. Sesión (11-Oct-2020)
Patrón selectivo. (Simple-Doble Múltiple)

Taller de Diseño de algoritmos

- Reglas de Negocio.
- Operadores Relacionales - Lógicos.
Reglas de negocio: Las Reglas del Negocio o Conjunto de Reglas de Negocio1 (Business
Rules, por su descripción en inglés) describe las políticas, normas, operaciones,
definiciones y restricciones presentes en una organización (Las organizaciones son
Entidades Sociales con estructuras administrativas y sistemas administrativos).
Ejemplo de reglas de negocio: "Un cliente al que facturamos más de 10.000 al año es un
cliente de tipo A", "A los clientes de tipo A les aplicamos un descuento del 10% en pedidos
superiores a 3.000".
Características. Las reglas de negocio deben ser.

● Declarativas y Atómicas.
● Construidas de manera independiente pero relacionada a los procesos.
● Expresadas en lenguaje natural o Formal (OCL)
● Orientadas al negocio.
La independencia en la definición de las reglas de negocio, es de vital importancia para las
suites BPM2 (Business Process Management o Gestión por procesos de Negocio) ya que
permite que si se dan cambios de políticas de la empresa, los Procesos se actualicen
automáticamente sin necesidad de cambiar las Clases de Proceso, únicamente bastaría con
cambiar las Reglas de Negocio.
Ej. en relación al cliente de tipo A, podríamos cambiar a esta nueva regla: "A los clientes de tipo
A les aplicamos un descuento del 15% en pedidos superiores a 5.000".
Principales reglas de negocio, explícitas o tácitas, que están embebidas en procesos y

aplicaciones informáticas,
Las 5 reglas principales.

1. Regla de modelo de datos: Implementa los tipos de datos (Integridad de dominio)
2. Regla de restricción: restringe los datos (refuerza el modelo de datos)
1 https://es.wikipedia.org/wiki/Reglas_de_negocio
2 Introducción a Business Process Management (BPM)

3. Regla de derivación: Permite obtener datos a partir de otros previos. Por
demanda.
4. Regla de relación: Implementa integridad relacional. (datos fantasma - huérfanos)
5. Regla de flujo: Administración segura y confiable del flujo de información.
Especificación Formal de las Reglas de Negocio.

Lenguaje de especificación OCL 2.0 (Object Constraint Language).
OCL 2.0 es un lenguaje para la descripción formal de expresiones en los modelos UML.
Como se implementan las Reglas de Negocio?.

Expresiones Relacionales - Lógicas (Simple y compuestas)
Operadores Relacionales.
Operadores Lógicos:
Ejemplo Comentado.
Patrón Selectivo: parte I

PATRÓN: Selectiva Simple.

Enunciado 1b. Implementar una aplicación que calcule el área del círculo geométrico.
1. Análisis.
El área del círculo se obtiene mediante la siguiente expresión:
Proceso:
A=π . r ❑2❑
En donde:
A es el área del circulo
π es la constante PI= 3.141592
r es el radio
Reglas de Negocio. Restricciones

- El usuario debe ingresar valores para el radio válidos.
- Los valores del radio son números reales (Regla de Modelo datos)
- Los valores del radio deben ser siempre positivos. (Regla de restricción).
OCL.
Context: Circulo
self.radio: real
inv:
self.radio > 0
Entradas: valor del radio de tipo real
Salidas: valor del área de tipo real
2. Diseño.
Algoritmo. Area circulo v2 (Considerar escenario de fallo)
var
real: radio, area
const PI <- 3.141592
inicio
//inicializacion
radio <- 0
area <- 0

//entrada consola
leer(radio)
//proceso
si( radio > 0 )entonces //exp. relacional simple / compuesta
area <- PI * radio^2
fin_si
//salida por consola

fin
3. Implementacion.
3.a C++
//Algoritmo. Area circulo v2 (Considerar escenario de fallo)
#include <cstdlib>
#include <iostream>
#include <cmath>
int main( int argc, char *argv[]){

//var
float radio, area;
//inicio
//inicializacion
radio = 0;
area = 0;
//entrada consola
//proceso
if( radio > 0 ){//entonces //exp. relacional simple / compuesta
area = PI * pow(radio,2);
}//fin_si

printf("Area circulo: %f\n", area);
}//fin
3.b. JS

var
radio, area;
const PI = 3.141592;
//inicio
//inicializacion
radio = 0;
area = 0;
//entrada consola
radio = prompt("Ingrese radio: ");
//proceso
if( radio > 0 ){//entonces
area = PI * Math.pow(radio,2);
}//fin_si

console.log("Area circulo: ", area);
//fin
3.c. Py
#Algoritmo. Area circulo v2

#var
# real: radio, area
PI = 3.141592
#inicio
#//inicializacion
radio = 0
area = 0
#//entrada consola
radio = float(input("Ingrese radio: "))
#//proceso
if( radio > 0 ):#entonces
area = PI * pow(radio,2)
#fin_si
#//salida por consola
print("Area circulo: ", area)
#fin
''' NOTA
Tipos de datos Ps C++ Py
------------------------------------------------
entero: num short num; int
int num;
long num;
real: area float area;
double area; float
------------------------------------------------

'''
3.d. PHP
<?php
//var
// real: radio, area
$PI = 3.141592;
//inicio
//inicializacion
$radio = 0;
$area = 0;
//entrada consola
$radio = readline("Ingrese radio: ");
//proceso
if( $radio > 0 ){//entonces
$area = $PI * pow($radio,2);
}//fin_si

print("Area circulo: " . $area);
//fin
?>
Patrón Selectivo: parte I (continuación)

PATRÓN: Selectivo Doble.
Versión 3. extendida:
NOTA: Regla explicita en el enunciado 1,b

OCL.
Context: Circulo
self.radio: real
inv:
self.radio > 0
regla implícita en el enunciado 1b.
radio > 0 (Explicita)
radio <= 0 (Implicita)
Validar 1ra regla si( radio > 0 )entonces

//proceso
fin_si
Validar 2da.regla si( radio <= 0 )entonces

//proceso
fin_si
Validar ambas reglas
si( radio > 0 )entonces
//proceso
si_no
//default
fin_si
2. Diseño.
Algoritmo. Area circulo v3.
var
real: radio, area
const PI <- 3.141592
inicio
//inicializacion
radio <-0
area <- 0
//entrada consola
leer(radio)
//proceso
si( radio > 0 )entonces //exp. relacional
area <- PI * radio^2 //exp. aritmetico
si_no
//default
escribir("Radio no valido")
fin_si

fin
3. Implementacion
3.a. C++

3.b. JS
3.c. Py
3.d PHP
<?php
//var
// real: radio, area
$PI = 3.141592;
//inicio
//inicializacion
$radio = 0;
$area = 0;
//entrada consola
$radio = readline("Ingrese radio: ");
//proceso
if( $radio > 0 ){//entonces //exp. relacional
$area = $PI * pow($radio,2); //exp. aritmetico
}else{
//default
print("Radio no valido");
print("\n");
}//fin_si

print("Area circulo: " . $area);
//fin
NOTA IMPORTANTE.
Notacion de procesos.
Exp. Aritmeticas
Op. Aritmeticos
+ - * / DIV MOD ^ ** , funciones potencia(), raizCuadrada(), etc

Notación de Reglas de negocio.
Exp. Relacionales
op. relacionales: < > <= >= = <>
radio > 0 (Regla: radio positivo)
Exp. logicas
op. logicos: Y O NO (and or not)
Patrón Selectivo: parte II

Implementar: Formatos Selectiva Múltiple.
Evalúa: Más de una Regla de Negocio.
Caso General: Múltiple anidada-cascada Caso Particular: Múltiple de casos

electiva Múltiple.
Definir selectiva múltiple mediante Técnica de anidamiento.
PASO 1. Punto de inicio: selectiva doble.
si( exp )entonces

//acciones o actividades
si_no
//default
fin_si
PASO 2. Anidamiento: en bloque default
si( exp )entonces

si_no
si( exp )entonces
si_no
si( exp )entonces
si_no
//default
fin_si
fin_si
fin_si

Ejemplo comentado
Nota: Clase 04 / Material de Estudio (selectivas Parte I - Parte II)
ENUNCIADO : Ingrese un número entre 1 y 3, luego visualice su equivalente en letras.

1. Analisis.
numero letras
-----------------------------------------------
1 Uno
2 Dos
3. Tres
----------------------------------------------
OCL
Context: E
self.numero: entero
inv:
self.numero.rango(1,3) //equivalente en letra
Entradas: numero en el rango [1 - 3], de tipo entero
Salidas : Equivalente respectivo, en letras (cadena)
Caso: General (Predeterminado)

2. Diseño.
Algoritmo Convertir numero a letras v1
var
entero: num
inicio
//entrada por consola
escribir("ingrese numero [1-3]: ")
leer(num)
//proceso
si( num = 1 )entonces
escribir("UNO")
si_no
escribir("DOS")
si_no
escribir("TRES")
si_no
//default
escribir("Numero fuera de rango")
fin_si
fin_si
fin_si
fin
3. Implementacion
3.a. C++.
//Algoritmo. Numero a letra v1.a
#include <cstdlib>
#include <iostream>
int main(int argc, char *argv[]){

//var
int num;
//inicio
printf("Ingrese numero [1-3]: ");
scanf("%d", &num);
if( num == 1 ){//entonces

puts("Uno");
}else if( num == 2 ){//entonces
puts("Dos");
}else if( num == 3 ){//entonces
puts("Tres");
}else{

//default
puts("Numero fuera de rango");
}//fin_si
//fin_si
//fin_si
}//fin
3.a. JS.
3.a. Py.
3.a. PHP.

Nota importante: Expresión de reglas de negocio - compueesta
Reglas de negocio. Exp.Mat Exp Computacional
[ 70, 90 >
70 <= x < 90 puntaje >= 70 Y puntaje < 90
Practica de Analisis / Diseño
Aplicar Tecnica de anidamiento. Reglas de negocio. etc. metodologicas

(2 ejercicios)


--------------------------------------------------------------------------------------------------------------------------
1.Prado [email protected]@gmail.com
10
2.FLORES Candela cristhian [email protected]
3
3.IZAGUIRRE BARBARAN, Romel Carlof [email protected] 7
4.JÁUREGUI, [email protected] 8
5. P.rìncipe [email protected] 11
6.Ascurra Risco Katherine Alejandra [email protected] 2
9.Linares Choque LIbia [email protected]
10.Villegas
[email protected]@gmail.com presente
11. Jáuregui Zanabria, Brenda [email protected]
------------------------------------------------------------------------------------------------------------------------
ALGBO-S6 Dom04Oct2020 3ra. Sesión (18-Oct-2020)
Nota:
exp. simple radio > 0 num = 1
exp.compuesta punt >= 70 Y punt < 90
2.b. Caso Particular.

2. Diseño.
Algoritmo. Numero a letra v1.b

var
entero: num
inicio
escribir("Ingrese numero [1-3]: ")

leer(num)
segun_sea( num )hacer

1: escribir("Uno")
2: escribir("Dos")
3: escribir("Tres")
si_no:
//default
fin_segun
fin

3. Implementacion.
3.a. C++
//Algoritmo. Numero a letra v1.b
#include <cstdlib>
#include <iostream>

//var
short num;
//inicio
printf("Ingrese numero [1-3]: ");

scanf("%hd", &num);
switch( num ){//hacer

case 1: puts("Uno");
break;
case 2: puts("Dos");
break;
case 3: puts("Tres");
break;
default:
//default
puts("Numero fuera de rango");
break;
}//fin_segun
}//fin
3.b. JS
//Algoritmo. Numero a letra v1.b
var
num;
//inicio
num = parseInt(prompt("Ingrese numero [1-3]: "));
switch( num ){//hacer

case 1: console.log("Uno");
break;
case 2: console.log("Dos");
break;
case 3: console.log("Tres");
break;
default:
//default

console.log("Numero fuera de rango");
break;
}//fin_segun
//fin
3.c. Py
ATENCION: no existe switch en Python, fue eliminada. El creados, Guido van Rossum, opto
por el patron predeterminado.
Eliminado por razones metodológicas…!
#Algoritmo. Numero a letra v1.b

#var
#entero: num
#inicio
num = int(input("Ingrese numero [1-3]: "))
segun_sea( num )hacer
1: escribir("Uno")
2: escribir("Dos")
3: escribir("Tres")
si_no:
//default
fin_segun
#fin

Patrón Repetitivo: Bucles o Loops

Definición y Sintaxis metodológica:
Bucle: “Tiene origen matemático y se basa en las sucesiones naturales”
Implementaciones: mientras / fin mientras (while) - Predeterminado

desde / fin_desde. (for)
repetir / hasta_que (do / while)
Definiciones complementarias:
a.- Mecanismos de control de bucle.
a.1.- Mecanismos de control de bucles
* Por contador (97%)
* Por centinela (1%)
* Por Bandera o Flag (1%)
* Por agotamiento (2%)
b.- Acumuladores - Contadores

b.1.- Acumuladores y contadores
s <- s + n //acumulador
k <- k + 1 //contador
------------------------------
i <- i + valor
------------------------------
si: valor es una variable - Acumulador (caso general)
valor es una constante - Contador (caso particular)
Ejemplo comentado.
Ejemplo 1 : Visualizar los 5 primeros números naturales.
1. Analisis.
proceso: visualizar 1, 2, 3, 4, 5
SUCESION 1er.Term. Ult.term.

n 1, 2, 3, 4, 5
\/ \/ \/ \/
razon: +1 +1 +1 +1
OCL.
Context: Conjunto Natural
self.n: entero
inv:
self.n <= 5 (Regla de restricción)

Entradas: numeros naturales del 1 al 5, de tipo entero
Salidas : visualizar terminos de la sucesion
Representación computacional: Bucle
n <- 1
(hasta 5)
//1er. termino
//iterac
//ult. termino
ion
n <- n + 1
//razon
Conclusión: Sucesión (Matemática) = Bucles (Computación)
Algoritmo. Bucle
Sucesión: var
entero: n
1er.Term. Ult.Term. inicio
N: 1, 2, 3, 4, 5 n <- 1 //1er.Term
\/ \/ \/ \/ mientras( hasta 5 )hacer
razón: +1 +1 +1 +1 // iteracion
n <- n + 1 //razon
fin_mientras
fin
2 Diseño.

Algoritmo. Buble-1 v.1

var
entero: n
inicio
n <- 1
mientras( hasta 5 )hacer
//iteracion
escribir("Termino: ", n)
n <- n + 1
fin_mientras
fin
3. Implementacion.
3.a. CPP
//Algoritmo. Buble-1 v.1
#include <cstdlib>
#include <iostream>

//var
short n;
//inicio
n = 1;
while( n <= 5 ){//hacer
//iteracion
printf("Termino: %d\n", n);
n = n + 1;
}//fin_mientras
}//fin
3.b. JSs
//Algoritmo. Buble-1 v.1

//var
// entero: n
//inicio
n = 1;
while( n <= 5 ){//hacer
//iteracion
console.log("Termino: " + n);
n = n + 1;
}//fin_mientras
//fin
3.b. Py
#Algoritmo. Buble v.1
#var
# entero: n
#inicio
n = 1
while( n <= 5 ):#hacer
#//iteracion
print("Termino: ", n)
n = n + 1
#fin_mientras
#fin
Ejemplo 2: Calcular y visualizar, la suma de los 5 primeros numeros

naturales.
2. Analisis.
Sucesion 1er.Term. Ult.term.

n 1, 2, 3, 4, 5
\/ \/ \/ \/
razon: +1 +1 +1 +1
Proceso: sumar terminos de la sucesion

suma (1 + 2 + 3 + 4 + 5)
OCL.
Context: N - conjunto de numeros Naturales
self.n: entero
inv:
self.n <= 5 (Regla de restricción)
Entradas: numeros naturales del 1 al 5, de tipo entero
Salidas : suma de la sucesion (serie)
2. Diseño.
Algoritmo Bucle v.2
var
entero: n, suma
inicio
suma <- 0
n <- 1 //1er.Term
// iteracion
suma <- suma + n
n <- n + 1 //razon
fin_mientras
escribir("Suma terminos: ", suma )
fin
Ejemplo 3: Calcular y visualizar, la suma de todos los números enteros de 2 cifras.

1. Analisis
1er,Term. Ult.Term.
numeros 10, 11, 12, ..., 98, 99
\/ \/ … \/
razon: +1 +1 +1
Proceso: sumar términos de la sucesion (Obtener la serie)

n = 99
Σ (i) = 10 + 11 + 12 + … + 98 + 99
i = 10

OCL.
Context: Z+
self.n: entero
inv:
self.n.rango(10, 99) (Regla de restricción)
Especificaciones E/S
Entradas: Terminos de la sucesión en el rango (10,99), de tipo entero
Salidas : Visualizar serie, de tipo entero
2. Diseño.
Algoritmo. Bucle v.3
var
entero: n, suma
inicio
suma <- 0
n <- 10
//iteracion
suma <- suma + n
n <- n + 1
fin_mientras
escribir("Suma terminos: ", suma )
fin
Ejemplo 4: Calcular y visualizar, la suma de todos los números impares de 3 cifras.

1. Analisis.
1er.Term Ult.Ter.
N 101, 103, 105, 107, … 995, 997, 999
\/ \/ \/ \/ \/
razon: +2 +2 +2 +2 +2
Proceso: suma de terminos de la sucesion (calcular la serie)
n = 999
Σ (i + 2) = 101 + 103 + 105 + ...997 + 999
i = 101
OCL.
Context: Naturales-impares
self.n: entero
inv:
self.n.rango(101, 999) (Regla de restricción)
self.n.step = +2
Especificaciones E/S

Entradas: Terminos de la sucesión en rango (101,999), de
tipo entero
Salidas : visualizar serie, de tipo entero
Algoritmo. Bucle v.4 (serie de numeros Z+ impares de 3 cifras)

var
entero: n, suma
inicio
suma <- 0
n <- 101
//iteracion
suma <- suma + n
n <- n + 2
fin_mientras
escribir("Serie: ", suma)
fin
Ejemplo 5. Calcular y visualizar los divisores de un numero entero.

1. Analisis.
Sea num 12 12 12 12 12 12 12 12 12
-- -- -- -- -- -- ... -- --
sucesión: denominador 1 2 3 4 5 6 11 12
resto 0 0 0 0 2 0 1 0
proceso: resto = num MOD d (módulo de la división)
Regla de negocio
si resto = 0
accion: visualizar denominador
2. Diseño.
Algoritmo. Divisores
var
entero: n, num, resto
inicio
escribir("ingrese numero: ")
leer(num)
n <- 1
mientras( hasta num )hacer
//iteracion
resto <- num MOD n
si(resto = 0)entonces
escribir(n)
fin_si

n <- n + 1
fin_mientra
fin
//Algoritmo. Divisores
#include <cstdlib>
#include <iostream>

//var
int n, resto, num;
//inicio
printf("ingrese numero: ");
scanf("%d", &num);
n = 1;
while( n <= num ){//hacer
//iteracion
resto = num % n;
if(resto == 0){//entonces
printf("Divisor: %d\n", n);
}//fin_si
n = n + 1;
}//fin_mientras
}//fin
Ejercicios: práctica de diseño.

Bucles - patrón predeterminado mientras / fin_mientras
Ejercicio 1 para Bucles: Dropbox clase 05 (Material de Estudio)
Dropbox clase 06 (Material de Estudio)
Ejercicio 2 Verificar que las estructuras: desde / fin_desde y repetir / hasta_que
están incluidas implícitamente en el patrón predeterminado.

NOTA: Observar que, son formas abreviadas del patrón Mientras (predeterminado

--------------------------------------------------------------------------------------------------------------------------
1.Prado Oré, Augusto Gerardo [email protected]

2.FLORES [email protected]
3.IZAGUIRRE BARBARAN, Romel Carlof (justificado) [email protected] 7
4.JÁUREGUI, [email protected] presente 8
5. P.rìncipe [email protected] 11
6.Ascurra Risco Katherine Alejandra [email protected] 2
10.Villegas Peña, Victor MIlton. [email protected] presente
11.
------------------------------------------------------------------------------------------------------------------------
ALGBO-S6 Dom04Oct2020 4ta. Sesión (25-Oct-2020)
Contenido.
Segundo Método:
b. Método: Programación Modular. (Procedimental)

1. Patrones: sub-rutina Procedure, sub-rutina Function.

2. Técnicas: Abstracción-Encapsulamiento-
Polimorfismo.
Programación Modular: Sub-algoritmos
procedimiento nombre(E/S tipo:

lista_prms)
var
Algoritmo. <nombre>
var inicio //proceso_encapsulado
fin_procedimiento
Invocacion
de sub-rutina
1
inicio //proceso_1 tipo: funcion nombre(E/S tipo:
lista_prms)
//proceso_2 //proceso_3 var
//proceso_nfin
Invocacion
de sub-rutina inicio //proceso_encapsulado
2
devolver (valor)fin_funcion
Programa principal (main) Sub-rutinas o Módulos.
Patrones:
1. Subrutina tipo Procedimiento (Predeterminado)
2. Subrutina tipo Funcion (Caso particular)
Construccion de modulos (Notación)

- Definición
- implementacion
- Declaración (según lenguaje: Estático / Dinámico)
- invocación

Sintaxis de la definición de prototipos
[tipo:] procedimiento | funcion nombre(E/S tipo: prm1, ...)

var
//sec. declaracion
inicio
//sec. de acciones - implementacion
[devolver (valor)]
fin_procedimiento | fin_funcion
Ejemplo Comentado.
Enunciado 1c. Implementar una aplicación que calcule el área y la longitud de la circunferencia del
círculo geométrico.
1. Análisis.
El área y circunferencia del círculo se obtiene mediante las siguientes expresiones:
Procesos: A = π .r ❑2
2.π .r
L=
En donde:
A es el área del circulo
L es la longitud de la circunferencia
π es la constante PI= 3.141592
r es el radio
Reglas de Negocio. constraints restricciones

OCL.
Context: Circulo
self.radio: real
inv:
self.radio > 0 exp. relacional ( >, <, =, >=, …)
Entradas: valor del radio, de tipo real
Salidas: valor del area y longitud de la circunferencia, de tipo real
2. Diseño del Algoritmo.

2.a. Especificación Pseudocódigo.
Algoritmo. Area y Longitud circulo v4.a. (Modo programa principal)
var
real: radio, area, longitud
const PI <- 3.141592

inicio
//inicializaciones
radio <- 0
area <- 0
longitud <- 0
//entrada consola
leer(radio)
//proceso
si( radio > 0 )entonces //exp. relacional
area <- PI * radio^2 //exp. aritmetico
longitud <- 2 * PI * radio
si_no
escribir("Radio no valido")
fin_si

escribir("Area del circulo: ", area)
escribir("y circunferencia: ", longitud)
fin
OBS Sobre los patrones Selectivos y Repetitivos:

Ambos validan reglas de negocio
Una sola vez Varias veces
Algoritmo. Area y Longitud circulo v4.b. (Modo programa principal)

var
const PI <- 3.141592
inicio
//inicializaciones
radio <- 0
area <- 0
longitud <- 0
//entrada consola
repetir
leer(radio)
hasta_que( radio > 0 )
//proceso 1

area <- PI * radio^2
//proceso 2
longitud <- 2 * PI * radio

fin
Método: Programación Modular
Algoritmo. Area y Longitud circulo v5. (Modo programa modular)

var
const PI <- 3.141592
inicio
//inicializaciones
radio <- 0
area <- 0
longitud <- 0
//entrada consola
repetir
leer(radio)
hasta_que( radio > 0 )
//proceso 1
//llamar_a calcularArea( radio, area)
area <- calcularArea( radio )
//proceso 2 llamar_a circunferencia( radio, longitud)

longitud <- circunferencia( radio )

fin
//definicion de prototipos
procedimiento calcularArea( E real: r; S real: a)
var
const PI <- 3.141592
inicio
a <- PI * r^2
fin_procedimiento
real: funcion calcularArea( E real: r)

var
real: a
const PI <- 3.141592
inicio
a <- PI * r^2
devolver ( a )
fin_funcion

procedimiento circunferencia( E real: r; S real: l)
var
const PI <- 3.141592
inicio
l <- 2 * PI * r
fin_procedimiento
//metodo polimorfico (sobrecargado)

real: funcion circunferencia( E real: r)
var
real: l
const PI <- 3.141592
inicio
l <- 2 * PI * r
devolver (l)
fin_funcion
3. Implementacion.
3.a. C++
//Algoritmo. Area y Longitud circulo v4.a. (Modo programa principal)
#include <cstdlib>
#include <iostream>
#include <cmath>

//var
float radio, area, longitud;
//inicio1
//inicializar
radio = 0;
area = 0;
longitud = 0;
//entrada consola
//proceso
if( radio > 0 ){//entoncces
area = PI * pow(radio,2); //Ps. asignar <- :=
longitud = 2 * PI * radio;
}else{
puts("Radio no valido");
}//fin_si
//salida consola
printf("Area del circulo: %f\n", area);
printf("y circunferencia: %fn", longitud);

}//fin.
//Algoritmo. Area y Longitud circulo v.4.b (Modo programa modular)

#include <cstdlib>
#include <iostream>
#include <cmath>

//var
//inicio
//inicializaciones
radio = 0;
area = 0;
longitud = 0;
//entrada consola
do{
}while( radio <= 0 );
//proceso
area = PI * pow(radio,2); //Ps. asignar <- :=
longitud = 2 * PI * radio;

printf("Area del circulo: %f\n", calcularArea( radio ));
printf("y circunferencia: %f\n", circunferencia(radio ));
}//fin
//Algoritmo. Area y Longitud circulo v5. (Modo programa modular)

#include <cstdlib>
#include <iostream>
#include <cmath>
//seccion de declaraciones
void calcularArea( float r, float &a);
void circunferencia( float r, float &l);

//var

//inicio1
//inicializarr
radio = 0;
area = 0;
longitud = 0;
//entrada consol
do{
//proceso 1
//llamar_a
calcularArea( radio, area);
//proceso 2
//llamar_a
circunferencia( radio, longitud);
//salida consola
printf("Area del circulo: %f\n", area);
printf("y circunferencia: %fn", longitud);
}//fin.
void calcularArea( float r, float &a){
//var
//inicio
a = PI * pow(r,2);
}//fin_procedimiento
void circunferencia( float r, float &l){

//var
//inicio
l = 2 * PI * r;
/*
prm: Ps C++
------------------------------------------------------
entrada E real: radio float radio; (by val)
------------------------------------------------------
salida S real: area float &area; (by ref)
float *area; (def. pointer)
-----------------------------------------------------
*/

//Algoritmo. Area y Longitud circulo v6.
#include <cstdlib>
#include <iostream>
#include <cmath>
//seccionn de declaraciones
void calcularArea( float r, float &a);
float calcularArea( float r);
void circunferencia( float r, float &l);
float circunferencia( float r);

//var
//inicio1
//inicializarr
//radio = 0;
//area = 0;
longitud = 0;
//entrada consol: leerRaddio()

do{
//proceso 1
//llamar_a calcularArea( radio, area);
//area = calcularArea( radio );
//proceso 2
//llamar_a circunferencia( radio, longitud);
//longitud = circunferencia( radio );
//salida consola: verResultados()

printf("Area del circulo: %f\n", calcularArea( radio ));
printf("y circunferencia: %fn", circunferencia( radio ));
}//fin.
void calcularArea( float r, float &a){
//var
//inicio
a = PI * pow(r,2);
float calcularArea( float r){

//var
float a;
//inicio
a = PI * pow(r,2);
return ( a );
}//fin_funcion

void circunferencia( float r, float &l){
//var
//inicio
l = 2 * PI * r;
//metodo polimorfico (sobrecargado)

float circunferencia( float r){
//var
float l;
//inicio
l = 2 * PI * r;
return (l);
}//fin_funcion


ALGBO - S6 Curso-01 Algoritmo Estructurado Basico - Metodologia de La Programacion.

Cargado por

Copyright:

Formatos disponibles

ALGBO - S6 Curso-01 Algoritmo Estructurado Basico - Metodologia de La Programacion.

Cargado por

Información del documento

Descripción original:

Título 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

ALGBO - S6 Curso-01 Algoritmo Estructurado Basico - Metodologia de La Programacion.

Cargado por

Copyright:

Formatos disponibles

Clases en Línea: Metodología de la Programación

Universidad Nacional de Ingeniería - FIIS

Curso I : Algoritmos & Estructura de Datos

2.- Método: Programación Modular (Procedimental)

Modelo de desarrollo: Semántica y sintaxis.

Jorge Medianero Acosta. Pag. 1

Aula: lista de alumnos:

1.Prado Oré, Augusto Gerardo [email protected] 10

Jorge Medianero Acosta. Pag. 2

Algoritmos: Análisis, Diseño e Implementación

Patrón secuencial: Taller de Diseño de algoritmos..

//salidas por consola

b. Especificacion UML (Activity Diagram).

3. Implementacion: Comprobación del algoritmo.

4. Modelo de Pruebas: Test Unit (Pruebas unitarias)

Jorge Medianero Acosta. Pag. 3

A=π . r ❑2❑ area <- PI * radio^2

2. Diseño del Algoritmo.

Algoritmo. Area circulo v1

3. Implementacion. (Comprobar algoritmo)

Jorge Medianero Acosta. Pag. 4

//Algoritmo. Area circulo v1

using namespace std;

int main( int argc, char *argv[] ){

Jorge Medianero Acosta. Pag. 5

4. Test de prueba: (Prueba Unitaria) [ Nota Adjunta-3 ]

Jorge Medianero Acosta. Pag. 6

Valor conocido ,para obtener un resultado predecible

Info sobre: OMG / UML [ Nota Adjunta 5 ]

Respuestas de los ejercicios propuestos: al correo: [email protected]

Aula: lista de alumnos:

Jorge Medianero Acosta. Pag. 7

1.Prado Oré, Augusto Gerardo [email protected]

4.JÁUREGUI ZANABRIA, Brenda [email protected]

Patrón selectivo. (Simple-Doble Múltiple)

Jorge Medianero Acosta. Pag. 8

Características. Las reglas de negocio deben ser.

Principales reglas de negocio, explícitas o tácitas, que están embebidas en procesos y

Las 5 reglas principales.

Jorge Medianero Acosta. Pag. 9

Especificación Formal de las Reglas de Negocio.

Como se implementan las Reglas de Negocio?.

Patrón Selectivo: parte I

Jorge Medianero Acosta. Pag. 10

Reglas de Negocio. Restricciones

Jorge Medianero Acosta. Pag. 11

//salida por consola

using namespace std;

int main( int argc, char *argv[]){

//salida por consola

Jorge Medianero Acosta. Pag. 12

//salida por consola

#Algoritmo. Area circulo v2

Jorge Medianero Acosta. Pag. 13

//salida por consola

Patrón Selectivo: parte I (continuación)

NOTA: Regla explicita en el enunciado 1,b

Jorge Medianero Acosta. Pag. 14