UNIVERSIDAD MAYOR REAL Y PONTIFICIA

DE SAN FRANCISCO XAVIER DE CHUQUISACA

FACULTAD DE CIENCIAS Y TECNOLOGIA

Práctica

CARRERA: INGENIERIA DE SISTEMAS

C.U: 35-4596

MATERIA: PROGRAMACION AVANZADA (SIS-457)

GRUPO: 2

SUCRE-BOLIVIA

2019
 SIS457 – PROGRAMACION AVANZADA - Práctica Nro. 1
Análisis Algorítmico – Patrones de Diseño

1. En el siguiente ejemplo, cuantas operaciones serían requeridas, represente a través de una expresión
matemática. Represente cada operación con una constante

for (int i = 1; i <= n; i++) {

//Se realizan 100 operaciones;
// A
for (int j = 1; j <= n; j++) {
//Se realizan 2 operaciones;
// B
}
}

Fa (n) = T (for_i)* C * T(for_j) * k = ∑ni≤n( ∑nj≤n) = ∑ni≤n(n) = n ∗ 100 ∗ n ∗ 2 = O = n2

La cantidad de operaciones se designa por : n*100 + n * 2

2. En las siguientes expresiones, ¿Cuál es la que consume más recursos?

Si consideramos la notación O Intuitivamente, sólo se considera el término más importante y se ignoran los
factores constantes. Por lo que indicamos que la segunda expresión es la que consume más recursos ( )
Debido a que este tipo de notación solo tomaría en cuenta la el mayor consumo de recursos como O = n3

3. Indique el termino más relevante en las siguientes expresiones, para poder obtener O ()

En esta expresión el termino relevante es n, O = n (ignorando constantes)

En esta expresión el termino relevante es n, O = n2 (ignorando constantes)

En esta expresión el termino relevante es n, O = n log( log n) (ignorando constantes, porque es el mayor orden)
4. ¿Cuál es la complejidad de las siguientes instrucciones?

Así es como sería el tiempo de ejecución y la complejidad del algoritmo para este problema:

{O (1)} T(n) = log (n) => O (log n)

La complejidad de esta instrucción es O (log n) para la primera instrucción. Sí, los bucles anidados son una
forma de obtener rápidamente una gran notación O. Normalmente (pero no siempre) un bucle anidado en otro
causará O (n²). El ciclo interno se ejecuta i veces, para cada valor de i. El ciclo externo se ejecuta n veces.

por lo tanto se ve un patrón de ejecución de la siguiente manera: 1 + 2 + 3 + 4 + ... + n veces, por lo tanto, nuestro
límite es de O (n log n).

5. Asuma que en las expresiones en la lista de abajo se cuenta con el tiempo T(n) de procesamiento que se
necesita para evaluar un dato “n” de entrada en el algoritmo. Determine ¿cuál o cuáles es/son el termino
dominante?

En esta expresión el termino dominate es n3 (mayor orden)

En esta expresión el termino domínate es n log n (mayor orden)
El termino domínate es n1.75 (mayor orden)
El termino domínate es n2 log2 n (mayor orden)
El termino domínate es n log 2 n (mayor orden)
El termino domínate es log 2 log 2 log 2 n (mayor orden, cuasilineal)
El termino domínate es n2 (mayor orden, ignorando constantes)

El termino domínate es n2 (mayor orden, ignorando constantes)

El termino domínate es n1.25 (mayor orden, ignorando constantes)

El termino domínate es n log 2 n2 (mayor orden, ignorando constantes)

El termino domínate es n3 (mayor orden, ignorando constantes)

El termino domínate es log 2 log 2 n (mayor orden, ignorando constantes)

6. Se cuenta con la clase descrita a continuación, implemente el patrón Singleton para poder utilizar una
sola instancia de la misma

public class Ball {

private String color;
public Ball (String color) { this.color = color; }
public void bounce() { System.out.println(“boing!”); }
}
Ball b1 = new Ball (“red”);
Ball b2 = new Ball (“blue”);
b1.bounce();
b2.bounce();

Rpta:

public class Ball {

private:
Ball(void);
static Ball* instancia;

private String color;

public:
static Ball* getInstance()
{
if(instancia == NULL)
{
instancia = new Ball();
}
return Ball;
}
public Ball (String color) { this.color = color; }
public void bounce() { System.out.println(“boing!”); }
}
Ball* Ball:: instancia = 0;

Ball b1 = new Ball (“red”);

b1.bounce();
b2.bounce();
7. Si se necesitara tener únicamente instancias de la pelota con colores: Rojo, Amarillo, Verde, Azul, Blanco
y Negro, que consideraciones deberían tomarse para poder aplicar el patrón?.

Observamos que el truco está en definir un constructor privado. Al hacerlo, ya no podremos

equivocarnos y crear varias instancias de esta clase, y la única forma de acceder al único objeto que
pueda haber en toda la aplicación es invocar al constructor privado de su clase utilizando la reflexión
para crear una nueva instancia de la clase.

public class Ball {

private:
Ball(void);
static Ball* instancia;

private String color;

public:
static Ball* getInstance()
{
if(instancia == NULL)
{
instancia = new Ball();
}
return Ball;
}
public Ball (String color) { this.color = color; }
public void bounce() { System.out.println(“boing!”); }
}
Ball* Ball:: instancia = 0;

Ball* B1 = new Ball (“rojo”);

Ball* B2= new Ball (“amarillo”);
Ball* B3= new Ball (“verde”);
Ball* B4= new Ball (“azul”);
Ball* B5= new Ball (“blanco”);
Ball* B6= new Ball (“negro”);

B1 = Ball::getInstance();
B2 = Ball::getInstance();
B3 = Ball::getInstance();
B4 = Ball::getInstance();
B5 = Ball::getInstance();
B6 = Ball::getInstance();

b1.bounce();
b2.bounce();
8. Implemente un ejemplo de los principios sólidos de Patrones de Diseño para un contexto de Videojuego,
Académico o Venta y compra de Productos. (Sigle responsability, Open-Closed, Liskov Substitution,
Interface segregation, Dependency Inversion)

Single responsability
Se basa en que Una clase class Videjuego {
debe tener una sola public void add (int x, int y) {
razón para cambiar. En System.out.println(x + y);
lenguajes estáticos y }
compilados de manera }
estática, varios motivos class Juego_maquina {
pueden llevar a varias public static void add(int x, int y) {
System.out.println(x + y);
implementaciones no
}
deseadas. Si hay dos }
razones diferentes para class Videojuego {//Esta clase solo es responsable de sumar números.
cambiar, es posible que public static int add(int x, int y) {
dos equipos diferentes return x + y;
puedan trabajar en el }
mismo código por dos }
razones diferentes. Cada
uno tendrá que class PrintStreamDecider { // Esta clase es la única responsable de
implementar su solución, decidir. // cual PrintStream es para ser usado
que en el caso de un public static PrintStream getPrintStream() {
lenguaje compilado return System.out;
}
}

class ResultPrinter { // Esta clase solo es responsable de imprimir

valores int.
public static void printResult(int value) {
PrintStreamDecider.getPrintStream().print(value);
}
}
class Juego_maquina { // esta clase solo es responsable de procesar la
solicitud de agregar dos números
public static void processTheAddCommand(int x, int y) {
int result = Videojuego.add(x, y);
ResultPrinter.printResult(result);
}
}
Open-Closed

Las entidades de software (clases,

módulos, funciones, etc.) deben estar public abstract class Tienda
abiertas para extensión, pero cerradas {
para modificación, La idea general de public abstract double local();
este principio es genial. Le indica que }
public class caja : Tienda
escriba su código para que pueda agregar
{
nuevas funciones sin cambiar el código
public double tiempo { get; set; }
existente. Eso evita situaciones en las que
public double dinero { get; set; }
un cambio en una de sus clases también public override double local()
requiere que adapte todas las clases {
dependientes. return tiempo*dinero;
}
El principal beneficio de este enfoque es }
que una interfaz introduce un nivel
adicional de abstracción que permite el public class kiosko: Tienda
acoplamiento suelto. Las {
implementaciones de una interfaz son public double horas { get; set; }
independientes entre sí y no necesitan public override double local()
compartir ningún código. Si considera {
que es beneficioso que dos return horas*horas*Math.PI;
implementaciones de una interfaz }
compartan algún código, puede usar }
public double local(Tienda[] tiendas)
la herencia o la composición
{
double local = 0;
foreach (var Tienda in tiendas)
{
local += Tienda.local();
}

return local;
}
Liskov Substitution

El principio de sustitución de Liskov class Rectangulo

{
(LSP) : las funciones que usan punteros protected int m_alto;
para basar las clases deben poder usar protected int m_ancho;
objetos de clases derivadas sin saberlo . public void setAlto(int alto){
m_alto = alto;
El LSP es necesario cuando algún }
código cree que está llamando a los public void setAncho(int ancho){
m_ancho = ancho;
métodos de un tipo T, y puede, sin }
saberlo, llamar a los métodos de un public int getAlto(){
tipo S, donde S extends T(es decir S, return m_alto;
hereda, deriva de, o es un subtipo de, el }
supertipo T). public int getAncho(){
return m_alto;
Por ejemplo, esto ocurre cuando una }
función con un parámetro de entrada public int getArea(){
de tipo Tse llama (es decir, se invoca) return m_alto * m_ancho;
}
con un valor de argumento de }
tipo S. O, cuando a un identificador class Cuadrado extends Rectangulo
de tipo T, se le asigna un valor de {
public void setAlto (int alto){
tipo S.
m_alto = alto;
m_ancho = alto;
}

public void setAncho (int ancho){

m_alto = ancho;
m_ancho = ancho;
}

}
class LspTest
{
private static Rectangulo getNewRectanulo()
{

return new Cuadrado();

}
public static void main (String args[])
{
Rectangulo r = LspTest.getNewRectangulo();

r.setAlto(5);
r.setAncho (10);

System.out.println(r.getArea());
}
}
Interface segregation

El Principio de Segregación de Interfaz (ISP): los clientes no deben ser obligados a depender de
las interfaces que no utilizan .

// El botón //////////////////////////////////////////// /////////////

class SomeButtonController {
public:
virtual void onButtonDown ( SomeButton * button ) = 0 ;
virtual void onButtonUp ( botón SomeButton * ) = 0 ; };
class SomeButton {
private:
SomeButtonController * _controller ;
public:
void setController ( SomeButtonController * controller );
};
// La ventana ////////////////////////////////////////////// /////////
class SomeWindowController {
public:
virtual void onWindowOpen ( SomeWindow * window ) = 0 ;
virtual void onWindowClose ( ventana de SomeWindow * ) = 0 ; virtual void onWindowMoved (
ventana de SomeWindow * ) = 0 ; };
class SomeWindow {
private:
SomeWindowController * _controller ;
public:
void setController ( SomeWindowController * controller );
}
// El controlador ////////////////////////////////////////////// /////////
clase SomeController : public SomeButtonController , public SomeWindowController {
private:
SomeWindow * _window ;
SomeButton * _okButton ;
SomeButton * _cancelButton ;
public:
void onButtonDown ( SomeButton * button );
void onButtonUp ( botón SomeButton * ); void onWindowOpen ( ventana de SomeWindow * ); vacío
onWindowClose ( ventana de SomeWindow * ); void onWindowMoved ( ventana de SomeWindow * ); };

SomeButton solo tiene acceso a los métodos de control relacionados con los botones, y

SomeWindow solo tiene acceso a los métodos de control relacionados con la ventana, aunque
los SomeController objetos se pueden conectar a ambos.
Dependency Inversion

El principio de inversión de dependencia (DIP) : los módulos de alto nivel no deben depender de los módulos de
bajo nivel. Ambos deben depender de las abstracciones.

El principio de inversión de dependencia es básicamente una forma de agregar enchufes y enchufes a su

código. Le permite crear sus módulos de alto nivel (la computadora) independientemente de los módulos de bajo
nivel (el mouse). Los módulos de bajo nivel se pueden crear más tarde y son fácilmente reemplazables.

// Este es el "tapón" (clase base abstracta)

class Exporter {

public:

// virtual pura (no implementado)

virtual String convertDocumentToString(Document* doc) = 0;

};

// Esta es una clase concreta que implemente el "tapón"

class CSVExporter : public Exporter {

public:

// implementación concreta
String convertDocumentToString(Document* doc);

};

// Otra clase concreta que implemente el "tapón"

class XMLExporter : public Exporter {

public:

// implementación concreta
String convertDocumentToString(Document* doc);
};

Es fundamental que todas las implementaciones / subclases se adhieran al principio de sustitución de

Liskov . Esto se debe a que las implementaciones / subclases se utilizarán a través de la interfaz abstracta, no de la
interfaz de clase concreta.