unidad didáctica 8

Tratamientos secuenciales I

Fundamentos de Programación

Departamento de Lenguajes y Sistemas Informáticos

Unidad Didáctica 8

Versión 1.0.0

UD8: Tratamientos secuenciales I

Índice

Introducción

Objetivo

Estructura lógica

Metodología - Resolución de problemas

Tratamientos:

Operaciones aritméticas:

“suma/producto”

Preguntas sobre propiedades:

“existe/para todo”

Máximos, mínimos


Introducción

Conceptos necesarios, ya vistos:

Diseño de tipos => creación de objetos.

Diseño de programas iterativos => uso de estructuras de

control iterativas o “bucles” (for clásico, for extendido, while)

Uso de agregados de objetos: List, Set, etc.

Conceptos nuevos:

Extraer información útil para un usuario final sobre los datos

contenidos en un agregado de objetos.


Objetivo

Dado un agregado de objetos (un List, un Set, etc.), nos

planteamos preguntas del tipo:

¿cuánto vale la suma de los …?

¿y el producto de los que verifican que …?

¿existe algún objeto que verifique …?

¿todos los objetos que cumplen que … verifican ...?

¿cuál es el valor más grande de los que … ?

¿según el orden … cuál es mayor que … ?

actualiza todos los objetos que …

etc.

Cada una de esas preguntas y otras similares pueden

implementarse a través de métodos con una

ESTRUCTURA COMÚN


Estructura lógica – Ejemplo I

¿Cómo se calcula la suma de los cuadrados de los

números enteros contenidos en un Vector de Enteros?

Como el agregado es un Vector usamos un for extendido para

recorrerlo. El código lo concretamos en un método que

tomando un Vector como parámetro devuelve el resultado

esperado.

public static Integer sumaCuadrados(Vector<Integer> v){

}

public static Integer sumaCuadrados(Vector<Integer> v){

Integer suma=0;

for (Integer e: v){

suma = suma + e*e;

}

return suma;

}


Estructura lógica – Ejemplo II

Sumar los cuadrados de los enteros contenidos en un

vector o en una secuencia que son múltiplos de 3.

public static Integer sumaCuadradosMultiplos3(Vector<Integer> v){

}

public static Integer sumaCuadradosMultiplos3(Vector<Integer> v){

Integer suma=0;

for(Integer e: v){

if(Enteros.esMultiplo(e,3)){

suma = suma + e*e;

}

}

return suma;

}

public static Integer sumaCuadradosIntervaloMultiplos3(Integer a,

Integer b, Integer c){

}

public static Integer sumaCuadradosIntervaloMultiplos3(Integer a,

Integer b, Integer c){

if(!(b>a && c>0)) throw new IllegalArgumentException();

Integer suma=0;

for(Integer e= a; e<=b; e=e+c){

if(Enteros.esMultiplo(e,3))

suma = suma + e*e;

}

return suma;

}


Estructura lógica

¿Cuál es entonces nuestro esquema?

Elementos a destacar:

Acumulador: es una variable que acumula el resultado calculado

hasta ese momento. Se inicializa al valor adecuado para la secuencia o

el agregado vacío y es del tipo del resultado que queramos calcular. En

el ejemplo, la variable es suma que se inicializa a cero y es de tipo

Integer, como el resultado.

Filtro: es una expresión lógica sin efectos laterales que nos sirve para

escoger los elementos del agregado sobre los que vamos a hacer el

cálculo. En este caso es la expresión Enteros.esMultiplo(e,3).

Expresión: es una expresión que a partir de cada objeto del agregado

calcula el valor que se va acumulando. En este caso la expresión es e*e.


Metodología - Resolución de problemas

Opciones:

1. Resolución mediante construcción directa de un bucle

(for extendido).

2. Generalización del código: diseño con tipos genéricos

e identificando las partes variables del método. Éstas se

pasarán como parámetros. En el caso de que el agregado

sea un Vector, las partes variables son: el agregado, el

filtro y la expresión.

A CONTINUACIÓN …

CLASE COLECCIONES(segunda parte de la asignatura)


Operaciones aritméticas

Sumatorio

• Operador: +

• Elemento Neutro: 0

ESQUEMA:

Double suma = 0.0;

for(T o: it){

if(…){

suma = suma + … ;

}

}

return suma;



public static Integer suma(List<Integer> l){

Integer suma = 0;

for(Integer e: l)

suma = suma + e;

return suma;

}

99 44 33 11 22

Iteración nº e suma

77

0 … 0



public static Integer suma (List<Integer> l){

Integer suma = 0;

//mostrar(“suma”+suma);

for(Integer e: l){

suma = suma + e;

//mostrar(e);

//mostrar(“suma”+suma);

}

return suma;

}

99 44 33 11 22

Iteración nº e suma

77

0 … 0

1 7 (0+7)

2 9 (0+7)+9

3 4 ((0+7)+9)+4 … etc …



Producto

• Operador: *

• Elemento Neutro: 1

ESQUEMA:

Double prod = 1.0;

for(T o: it){

if(…){

prod = prod * … ;

}

}

return prod;


Preguntas sobre propiedades

P Q ! P P || Q P && Q

true true false true true

true false false true false

false true true true false

false false true false false

(Repasemos cómo funcionan los operadores lógicos)

TABLA DE VERDAD:



Propiedad:

¿para todo elemento se verifica?

• Operador: &&

• Elemento Neutro: true

ESQUEMA:

Boolean r = true;

for(T o: it){

if(…){

r = r && … ;

}

}

return r;



Propiedad:

¿existe algún elemento que verifica que …?

• Operador: ||

• Elemento Neutro: false

ESQUEMA:

Boolean r = false;

for(T o: it){

if(…){

r = r || … ;

}

}

return r;



// ¿Existe algún número par en v?

public static Boolean existePar (List<Integer>

l){

Boolean res = false;

for(Integer e: l)

res = res || (e%2==0);

return res;

}

99 44 33 11 22

Iteración nº ¿e es par? res

77




public static Boolean existePar (List<Integer> l){


for(Integer e: l)

res = res || (e%2==0);

return res;

}

99 44 33 11 22

Iteración nº ¿e es par? res

0 --- false

1 false false || false -> false

2 false false || false -> false

3 true false || true -> true

4

77

false true || false -> true … etc …

¿Cómo sería un método que responda si todos los elementos son números pares?




public static Boolean existePar (List<Integer> l){


for(Integer e: l)

res = res || (e%2==0);

return res;

}

Nota:

Tratamiento no eficiente pues encuentra un

elemento que cumple la propiedad y sin

embargo sigue con las comprobaciones.

¿cómo podemos conseguir la eficiencia?


Preguntas sobre propiedades//Versión eficiente nº1: (uso de break)

public static Boolean existeParEficienteN1 (List<Integer> l){


for(Integer e: l){

res = res || (e%2==0);

if(e%2==0)

break;

}

}

return res;}

//Versión eficiente nº2: (“variable de frenado” dentro de un while)

public static Boolean existeParEficienteN2 (List<Integer> l){


int i=0;

while(i<l.size() && !res){

if(l.get(i)%2==0){

res = true;

}

i++;//¿qué ocurre si olvidamos esta instrucción?

}return res;}



¿para todo …? VERSIÓN EFICIENTE

ESQUEMA:

Boolean r = true;

for(T o: it){

if(…){

r = r && … ;

if(!r){

break;

}

}

}

return r;



¿existe …? VERSIÓN EFICIENTE

ESQUEMA:

Boolean r = false;

for(T o: it){

if(…){

r = r || … ;

if(r){

break;

}

}

}

return r;


Máximos, mínimos

máximo vs. mínimo:

• Elemento neutro: null

• Operador:

operación comparación 2 a 2

ESQUEMA:T a=null;

for(T e:it)

//a = (a==null? e: Utiles.max(e,a));

if(a==null)

a = e;

else

a = Utiles.max(e,a);

return a;

(análogo para

el mínimo)


Máximos, mínimos

máximo vs. mínimo: (versión con filtrado)

• Elemento neutro: null

• Operador:

operación comparación 2 a 2

ESQUEMA:T a=null;

for(T e:it)

if(…){

a = (a==null? e: Utiles.max(e,a));

}

if(a==null)

throw new NoSuchElementException(“…”);

return a;

(análogo para

el mínimo)


Máximos, mínimos

99 44 33 11 22

Iteración nº ¿mayor(a,res)->? resultado

77

0

1

2

3

4

resultado ->7 ---

(7,9)->9 resultado ->9

(9,4)->9 resultado ->9

… etc …


Máximos, mínimos

//El ejemplo anterior:(versión “intuitiva”)

public static Integer maxValor(List<Integer> l){

//Primer candidato el primer elemento

Integer res = l.get(0);

for(Integer e:l){//¿Nuevo elemento mayor? Si fuera así, lo cambio

if(res.compareTo(e)<0)//if(res<e)

res = e;

}

return res ;

}


Máximos, mínimos

/*El ejemplo anterior:

*(versión basada en operador binario máximo de dos

*elementos)*/

public static Integer

maxValor_version2(List<Integer> l){

Integer a=null;

for(Integer e:l)

a = a==null? e: Utiles.max(e,a);

return a;

}


Máximos, mínimos

public class Utiles{

/*Método auxiliar para calcular el máximo de dos

*elementos: tipos genéricos (ampliando a

*supertipos) usando orden natural del tipo */

public static <E extends Comparable<? super

E>> E max(E e1, E e2){

return e1.compareTo(e2)>= 0 ? e1 : e2;

}

// …

}


Máximos, mínimos

El esquema para el máximo y el mínimo puede ser

mejorado si el tratamiento del primer elemento es

incluido en el máximo binario:

//Versión “robusta” de max binario

public static <T extends Comparable<? super T>> T max(T o1, T o2) {

T o=null;

if(o1!=null && o2!=null){

if(o1.compareTo(o2)>=0)

o=o1;

else

o=o2;

} else {

if(o1==null)

o=o2;

if(o2==null)

o=o1;

}

return o;

}


Máximos, mínimos

máximo vs. mínimo: versión mejorada

El tratamiento del primer elemento está incluido en el

operador binario Utiles.max(-,-).

ESQUEMA:T a=null;

for(T e:it)

a = Utiles.max(e,a);

}

return a;

Nota 1: la opción de filtrado se puede añadir de

manera análoga a como se hizo con la versión anterior

Nota 2: el uso del operador Utiles.max(-,-) en su

versión robusta evita el disparo de excepciones

cuando haya valores perdidos (null) en el agregado.

(análogo para

el mínimo)


Búsquedas

Búsqueda

• Operador: =

• Elemento Neutro: --

ESQUEMA:

T b = null;

for(T e: it){

if(...){

b=e;

break;

}

}

return b;

unidad didáctica 8

Documents