ALGBO - S6 Curso-01 Algoritmo Estructurado Basico - Metodologia de La Programacion.
ALGBO - S6 Curso-01 Algoritmo Estructurado Basico - Metodologia de La Programacion.
ALGBO - S6 Curso-01 Algoritmo Estructurado Basico - Metodologia de La Programacion.
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
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
------------------------------------------------------------------------------------------------------------------------
ALGBO-S6 Dom04Oct2020 1ra. sesion (04-Oct-2020)
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
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:
En donde:
A es el área del círculo.
π es la constante PI = 3.141592
r es el radio
Especificaciones de E/S
Entradas: Valor del radio, de tipo real
Salidas : area del circulo, de tipo real
//proceso
area <- PI * radio^2 // asignar <- :=
//salida consola
escribir("Area circulo: ", area)
fin.
//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
//Algoritmo. Area circulo v1
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
*/
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
'''
Taller de Diseño:
Proyecto colaborativo - Patrón secuencial [ Nota Adjunta-4 ]
[ Nota de Descarga-2 ]
Sesion 02
--------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------
ALGBO-S6 Dom04Oct2020 2da. Sesión (11-Oct-2020)
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".
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".
1 https://es.wikipedia.org/wiki/Reglas_de_negocio
2 Introducción a Business Process Management (BPM)
Operadores Lógicos:
Ejemplo Comentado.
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
OCL.
Context: Circulo
self.radio: real
inv:
self.radio > 0
Especificaciones de E/S
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
escribir("Ingrese radio: ")
leer(radio)
//proceso
si( radio > 0 )entonces //exp. relacional simple / compuesta
area <- PI * radio^2
fin_si
3. Implementacion.
3.a C++
//Algoritmo. Area circulo v2 (Considerar escenario de fallo)
#include <cstdlib>
#include <iostream>
#include <cmath>
//entrada consola
printf("Ingrese radio: ");
scanf("%f", &radio);
//proceso
if( radio > 0 ){//entonces //exp. relacional simple / compuesta
area = PI * pow(radio,2);
}//fin_si
return EXIT_SUCCESS;
}//fin
3.b. JS
//Algoritmo. Area circulo v2
//proceso
if( radio > 0 ){//entonces
area = PI * Math.pow(radio,2);
}//fin_si
3.c. Py
''' 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
//Algoritmo. Area circulo v2
//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
//fin
?>
//entrada consola
escribir("Ingrese radio: ")
leer(radio)
//proceso
si( radio > 0 )entonces //exp. relacional
area <- PI * radio^2 //exp. aritmetico
si_no
//default
escribir("Radio no valido")
fin_si
3. Implementacion
3.a. C++
3.c. Py
3.d PHP
<?php
//Algoritmo. Area circulo v2
//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
//fin
NOTA IMPORTANTE.
Notacion de procesos.
Exp. Aritmeticas
Op. Aritmeticos
+ - * / DIV MOD ^ ** , funciones potencia(), raizCuadrada(), etc
electiva Múltiple.
Definir selectiva múltiple mediante Técnica de anidamiento.
Ejemplo comentado
Nota: Clase 04 / Material de Estudio (selectivas Parte I - Parte II)
OCL
Context: E
self.numero: entero
inv:
self.numero.rango(1,3) //equivalente en letra
Especificaciones de E/S
Entradas: numero en el rango [1 - 3], de tipo entero
Salidas : Equivalente respectivo, en letras (cadena)
//proceso
si( num = 1 )entonces
escribir("UNO")
si_no
si( num = 2 )entonces
escribir("DOS")
si_no
si( num = 3 )entonces
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>
return EXIT_SUCCESS;
}//fin
3.a. JS.
3.a. Py.
3.a. PHP.
[ 70, 90 >
--------------------------------------------------------------------------------------------------------------------------
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
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
[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
fin
3. Implementacion.
3.a. C++
//Algoritmo. Numero a letra v1.b
#include <cstdlib>
#include <iostream>
return EXIT_SUCCESS;
}//fin
3.b. JS
//Algoritmo. Numero a letra v1.b
var
num;
//inicio
//fin
3.c. Py
ATENCION: no existe switch en Python, fue eliminada. El creados, Guido van Rossum, opto
por el patron predeterminado.
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%)
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
OCL.
Context: Conjunto Natural
self.n: entero
inv:
self.n <= 5 (Regla de restricción)
n <- 1
(hasta 5)
//1er. termino
//iterac
//ult. termino
ion
n <- n + 1
//razon
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.
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>
n = n + 1;
}//fin_mientras
return EXIT_SUCCESS;
}//fin
3.b. JSs
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
Especificaciones de E/S
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
mientras( hasta 5 )hacer
// iteracion
suma <- suma + n
n <- n + 1 //razon
fin_mientras
escribir("Suma terminos: ", suma )
fin
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
mientras( hasta 99 )hacer
//iteracion
suma <- suma + n
n <- n + 1
fin_mientras
escribir("Suma terminos: ", suma )
fin
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
n <- n + 2
fin_mientras
escribir("Serie: ", suma)
fin
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
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>
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
return EXIT_SUCCESS;
}//fin
------------------------------------------------------------------------------------------------------------------------
ALGBO-S6 Dom04Oct2020 4ta. Sesión (25-Oct-2020)
Contenido.
Segundo Método:
Algoritmo. <nombre>
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
Patrones:
1. Subrutina tipo Procedimiento (Predeterminado)
2. Subrutina tipo Funcion (Caso particular)
[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
Especificaciones de E/S
Entradas: valor del radio, de tipo real
Salidas: valor del area y longitud de la circunferencia, de tipo real
//entrada consola
escribir("Ingrese radio: ")
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
//entrada consola
repetir
escribir("Ingrese radio: ")
leer(radio)
hasta_que( radio > 0 )
//proceso 1
//proceso 2
longitud <- 2 * PI * radio
//entrada consola
repetir
escribir("Ingrese radio: ")
leer(radio)
hasta_que( radio > 0 )
//proceso 1
//llamar_a calcularArea( radio, area)
area <- calcularArea( radio )
//definicion de prototipos
procedimiento calcularArea( E real: r; S real: a)
var
const PI <- 3.141592
inicio
a <- PI * r^2
fin_procedimiento
3. Implementacion.
3.a. C++
//Algoritmo. Area y Longitud circulo v4.a. (Modo programa principal)
#include <cstdlib>
#include <iostream>
#include <cmath>
//entrada consola
printf("Ingrese radio: ");
scanf("%f", &radio);
//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);
//entrada consola
do{
printf("Ingrese radio: ");
scanf("%f", &radio);
}while( radio <= 0 );
//proceso
area = PI * pow(radio,2); //Ps. asignar <- :=
longitud = 2 * PI * radio;
return EXIT_SUCCESS;
}//fin
//entrada consol
do{
printf("Ingrese radio: ");
scanf("%f", &radio);
}while( radio <= 0 );
//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);
return EXIT_SUCCESS;
}//fin.
//definicion de prototipos
void calcularArea( float r, float &a){
//var
const float PI = 3.141592;
//inicio
a = PI * pow(r,2);
}//fin_procedimiento
/*
prm: Ps C++
------------------------------------------------------
entrada E real: radio float radio; (by val)
------------------------------------------------------
salida S real: area float &area; (by ref)
float *area; (def. pointer)
-----------------------------------------------------
*/
//proceso 1
//llamar_a calcularArea( radio, area);
//area = calcularArea( radio );
//proceso 2
//llamar_a circunferencia( radio, longitud);
//longitud = circunferencia( radio );
return EXIT_SUCCESS;
}//fin.
//definicion de prototipos
void calcularArea( float r, float &a){
//var
const float PI = 3.141592;
//inicio
a = PI * pow(r,2);
}//fin_procedimiento