Ejercicios Pract. 1

Ejercicios Tema 1 de Exámenes de Prácticas de AD2
Ejercicio 2 – Junio’00. Se desea contrastar experimentalmente la eficiencia de los algoritmos de
búsqueda secuencial ascendente y de búsqueda binaria. En concreto, se está interesado en estudiar la
cota superior de coste temporal de los dos algoritmos.
type Vector=array[1..N] of integer;
function BuscaSec (var v:Vector; x:integer; talla:integer):integer;
Begin
...
... { Se supone ya implementado }
...
End;
function BuscaBin (var v:Vector; x:integer; talla:integer):Integer;
Begin
...
... { Se supone ya implementado }
...
End;
Una de las instancias que corresponden al caso peor de los dos algoritmos en consideración, se da
cuando se efectúa la búsqueda, en un vector ordenado ascendentemente, de un elemento cuyo valor sea
superior al máximo valor existente en el vector. Supongamos definido el siguiente procedimiento
genera un vector ordenado de tamaño n:
procedure GeneraInstancia (var v:Vector; n:integer);
Escribid el segmento de programa que realizaría el estudio de costes sobre vectores ordenados
ascendentemente, de tamaños: 200, 400, 600, 800, 1000, 1200, 1400, 1600, 1800, 2000.
Además, para cada uno de los casos, el valor buscado debe ser superior al último valor (máximo) del
vector. Para ello se utilizará la función clock, cuyo perfil es el siguiente:
function clock: integer;
Para que las medidas de temporización del reloj sean apreciables, se repetirá 1000 veces el algoritmo
de búsqueda secuencial ascendente, y 100000 veces el algoritmo de búsqueda binaria. Al acabar la
misma, se dividirá el tiempo obtenido por 1000 y 100000, respectivamente. La salida deberá ser
tabulada, con un formato similar al siguiente:
Ejercicio 2 – Septiembre’00. Se desea contrastar experimentalmente la eficiencia de los algoritmos de
Suma y Producto Matricial.
type Matriz=array[1..N, 1..N] of real;
Procedure SumaMat (var a,b:Matriz; var c:Matriz; talla:integer);
Begin
...
...
{ Se supone ya implementado }
...
End;
Procedure ProdMat(var a,b:Matriz; var c:Matriz; talla:integer);
Begin
...
...
{ Se supone ya implementado }
...
End;
Supongamos definido el siguiente procedimiento que genera una matriz cuadrada de dimensión n:
procedure GeneraInstancia (var M:Matriz; n:integer);
Escribid el segmento de programa que realizaría el estudio de costes sobre matrices de tamaños: 10,
20, 30, 40, ..., 100. Incluyendo las declaraciones de constantes y variables necesarias.
Para ello se utilizará la función clock, cuyo perfil es el siguiente:
function clock: integer;
Para que las medidas de temporización del reloj sean apreciables, se repetirá 100 veces el algoritmo de
suma matricial, y 10 veces el algoritmo de producto matricial. Al acabar, se dividirá el tiempo
obtenido de la manera adecuada.
La salida deberá ser tabulada, con un formato similar al siguiente:
# Tiempos de ejecución de operaciones matriciales (en microsegundos)
# Talla
Suma
Producto
# ---------------------...
.....
.....
(3 puntos)
# Tiempos de ejecución de la búsqueda (en microsegundos)
# Talla Secuencial Binaria
# ----- ---------- --------200 5.0E+01 4.4E+00
400 1.0E+02 4.9E+00
--- ----- -----
Página 1 de 1
Página 2 de 2
Ejercicio 2 – Junio’01. Se desea evaluar experimentalmente la eficiencia del siguiente algoritmo
contando el número de veces que se ejecuta el cuerpo del bucle más interno:
program ejer2 (...);
# valor de i iteraciones internas
cons n = …
# ----------- ---------------------var i, j: integer;
1
1
begin
2
2
i := 1;
3
2
while i <= n do
begin
4
3
j := 1;
5
3
while
j <= i do
j := j * 2;
i := i + 1;
end
end.
- tabla que se desea obtener - programa Se pide: modificar el programa para obtener por pantalla la tabla de la derecha. (2 puntos)
Página 3 de 3
Ejercicio 2-Septiembre’01. Se desea evaluar
contando el número de veces que se ejecuta
variable i.
program ejer2 (...);
# valor de i
const n = …
# ----------var i:integer; x,y:real;
0
begin
1
i := 0; y := 1;
2
while i <= n do
begin
3
x := y;
4
while x >= 10 do
5
x := x / 10;
6
i := i + 1;
7
y := y * 3;
end
experimentalmente la eficiencia del siguiente algoritmo
el cuerpo del bucle más interno para cada valor de la
iteraciones internas
---------------------0
0
0
1
1
2
2
3
end.
- tabla que se desea obtener - programa Se pide: modificar el programa para obtener por pantalla la tabla de la derecha. (2 puntos)
Página 4 de 4
Ejercicio 1. En numerosos problemas de computación numérica aparecen datos matriciales que tienen
una estructura triangular. Por ejemplo, una matriz cuadrada Mnxn se define triangular superior si todos
los elementos por debajo de la diagonal principal - desde la posición (1,1) a la (n,n) - son ceros. Es
decir: ∀j,i: 1≤ j< i≤ n: M[i,j] =0
Ejemplos (con n=4): triangular_superior (M1)=cierto y triangular_superior (M2)=falso
M1 =
1
0
0
0
3
2
0
0
8
5
3
0
20
12
7
4
M2 =
1
0
0
2
3
2
0
0
8
5
3
0
20
12
7
4
Se quiere hacer un análisis a posteriori, de la función triangular_superior que ha sido implementada en
Pascal, a través de la técnica de temporización (es decir, utilizando la primitiva de sistema clock) para
medir el tiempo consumido para tallas: 10, 20, 30, …, 100. Para obtener tiempos significativos se
deberá repetir la operación un número suficiente de veces repeticiones=100.
Se pide (puntuación: 1.5 puntos): rellenar el cuerpo del programa para obtener la tabla
correspondiente y cambiar la cabecera y el cuerpo de la subrutina triangular_superior si necesario:
Ejercicio 1. En numerosos problemas de computación numérica (por ejemplo, en problemas de
interpolación) aparecen datos matriciales que tienen una estructura tridiagonal. Una matriz cuadrada
Mnxn se define tridiagonal si son ceros todos sus elementos que no pertenecen a la diagonal principal –
desde (1,1) a (n,n) – y a las diagonales secundarias inferior – desde (2,1) a (n, n-1) – y superior – desde
(1,2) a (n-1,n). Los dos ejemplos (con n=4) ilustran casos de matrices tridiagonal y no tridiagonal.
Se quiere hacer un análisis a posteriori, de la función tridiagonal que ha sido implementada en Pascal,
a través de la técnica de temporización (es decir, utilizando la primitiva de sistema clock) para medir el
tiempo consumido para tallas: 10, 20, 30, …, 100. Para obtener tiempos significativos se deberá repetir
la operación un número suficiente de veces repeticiones=100.
Se pide (puntuación: 1.5 puntos): rellenar el cuerpo del programa para obtener la tabla
correspondiente y cambiar la cabecera y el cuerpo de la subrutina tridiagonal y/ las subrutinas si
necesario:
M1 =
1
2
0
0
4
7
6
0
0
4
1
0
0
0
0
6
M2 =
1
0
0
2
0
6
5
0
8
1
1
0
0
0
0
8
Talla Tiempo
10
20
.
.
100
Talla Tiempo
10
20
.
.
100
Program temporización_matriz_triangular (input, output);
const n = 100;
talla_inicial = 10;
incremento = 10;
repeticiones = 100;
type
elVector = array [1..n] of real;
laMatriz = array [1..n] of elVector; {equivalente a: laMatriz = array [1..n, 1..n] of real;}
var
indice_talla, indice_repeticiones, t1, t2: integer;
mg: laMatriz;
Program temporizacion_matriz_tridiagonal (input, output);
const n = 100;
talla_inicial = 10; incremento = 10; repeticiones = 100;
type
laMatriz = array [1..n,1..n] of real;
var
indice_talla, indice_repeticiones, t1, t2: integer;
mg: laMatriz;
function linea_tri_sup (var v: elVector; columna: integer): boolean; {llamada inicial con: (columna=linea–1) ∧ (1≤linea≤n)}
begin
if (columna = 0) then linea_tri_sup := true
else if v[columna] <> 0 then linea_tri_sup := false else linea_tri_sup := linea_tri_sup(v, columna –1)
end;
function tridiagonal (var m: laMatriz): boolean;
var
i,j: integer;
tridiag: boolean;
begin
tridiag:=true;
(COMENTARIO)
i:=1;
while (i < n-1) and tridiag do begin
j:=i+2;
while (j =n) and tridiag do begin
if ( m[i,j] <> 0 ) or ( m[j,i] <> 0 )
then tridiag:= false
else j:=j+1
end;
i:=i+1
end;
tridiagonal:= tridiag
end;
{cambiar / corregir la cabecera y/o el cuerpo si necesario}
function triangular_superior (var m: laMatriz): boolean;
var
lin: integer; triangular: boolean;
begin
triangular:=true;
lin:=2;
while (lin<= n) and triangular do begin
triangular:= linea_tri_sup ( m[lin], lin-1);
lin:=lin+1
end;
triangular_superior:=triangular
end;
{cambiar / corregir la cabecera y/o el cuerpo si necesario}
{COMENTARIO se comprueba si todos los elementos en la parte triangular superior a las diagonales (secundarias) de la
matriz son ceros y al mismo tiempo si los elementos de la parte triangular inferior son también ceros}
begin {cuerpo del programa para el análisis a posteriori}
begin {del programa principal}
end.
end.
Página 5 de 5
res:boolean;
Página 6 de 6