Primer Parcial Desarrollo Sistemático de Programas 2009

1. Analizar el costo y orden del siguiente algoritmo.

m1
repetir
para i desde 1 hasta n hacer
para j desde 1 hasta i hacer
Muestra(A[j], A[i])
fin para
fin para
m  m+1
hasta que (m>n)

Considere un costo 1 y costo 3 para Muestra.

2. Calcule el orden y costo de la siguiente recurrencia aplicando el Teorema Maestro y

resolviendo por el método iterativo de n=1 es 1 y n<>1 es 2*T(n/5)+n³.

3. Proponga un algoritmo recursivo e iterativo para mostrar los números impares de 1 a N.

Determine cual es mejor.
Primer Parcial Desarrollo Sistemático de Programas 2009

Desarrollo del ítem 1

i
C1=2+ 2+3
j=1
n
C2=2+ 2+C1
i=1

C3=2+1+C2
T(n)=C3+1
i i
C1=2+ 2+3=2+ 5=5*i+2
j=1 j=1
n n n n n
C2=2+ 2+C1=2+ 2+5*i+2=2+ 4+5*i=2+ 4+5* i=
i=1 i=1 i=1 i=1 i=1

n*(n+1) 5 5 5 13
=2+4*n+5* =2+4*n+ *n2+ *n=2+ *n2+ *n
2 2 2 2 2
n
5 13 n
5 13
C3= 2+1+2+ *n2+ *n= 5+ *n2+ *n=
i=1 2 2 i=1 2 2
n
5 n
13
n
5 13 2
= 5+n * +n* =5*n+ *n3+
2
*n
i=1 i=1 2 i=1 2 2 2

5 13 2
T(n)=C3+1=5*n+ *n3+ *n +1 O(n3 )
2 2

Desarrollo del ítem 2

n
T(n)=2*T( )+n3
5
 n n 
3
n 2
T(n)=2* 2*T( )+    =4*T( )+ *n3
 25  5   25 125
 n  n  
3
2 n 4 2
T(n)=4* 2*T( )+   + *n3=8*T( )+ 2
*n3+ *n3
 125  25   125 125 125 125
 n  n  
3
4 2
T(n)=8* 2*T( )+   + 2
*n3+ *n3=
 625  125   125 125
n 8 4 2
=16*T( )+ 3
*n3+ 2
*n3+ *n3
625 125 125 125
i
n k-1
 2  3
T(n)=2 *T( k )+ 
k
n
5 i=0  125 

n
T(1)=1 k
=1  n=5k  k=log5N
5
1-log5N i
n  2  3
T(n)=2log5N
*T(
5log5N
)+ 
i=0
 125  n
 
Primer Parcial Desarrollo Sistemático de Programas 2009

1-log5n i
 n   2  3
T(n)=2log5n *T  log5n  +
5 

i=0
 125  n
 
1-log5n i
 n   2 
T(n)=n log5 2
*T  log5 5  +n3 *
n 

i=0
 125 
 
log n 0
 2   2 
5

  - 
 n  125   125 
T(n)=nlog5 2 *T  log5 5  +n3 * 
n  2
-1
125
2
log5
n n 125 -1
T(n)=nlog5 2 *T   +n3 *
n 123
-
125
log5 2-log5 125
n -1
T(n)=nlog5 2 *1+n3 *
123
-
125
log5 2-3
n -1
T(n)=nlog5 2+n3 *
123
-
125
log5 2
n
3
-1
log5 2
T(n)=n +n * 3 n
123
-
125
log5 2
n -n3
T(n)=nlog5 2+n3 * n3
123
-
125
125*(nlog5 2 -n3 )
T(n)=nlog5 2+n3 *
-123*n3
n3 125*(nlog5 2 -n3 )
T(n)=nlog5 2+ 3 *
n -123
log5 2
125*(n -n3 )
T(n)=nlog5 2+
-123
log5 2 125*nlog5 2 -125*n3
T(n)=n +
-123
log5 2
125*n -125*n3
T(n)=nlog5 2+ +
-123 -123
125 125
T(n)=nlog5 2 -
123
*nlog5 2+
123
*n3  
O n3
Primer Parcial Desarrollo Sistemático de Programas 2009

Desarrollo del ítem 3

procedimiento MostrarImparesI(E entero: n)

variables
entero: i
inicio
para i desde 1 hasta n con paso 2 hacer
escribir(n)
fin para
fin

n/2 n/2
n 3
T(n)=2+ 2+1=2+ 3=2+3* = *n+2
i=1 i=1 2 2

procedimiento MostrarImparesR(E entero: n)

inicio
si (n=1) entonces
escribir(1)
sino
MostrarImparesR(n-2)
escribir(n)
fin si
fin
//Si N es par la sentencia escribir se ejecuta n/2
//Si N es impar la sentencia escribir se ejecuta n/2+1=(n+2)/2. Se considera el peor caso.
2 n=1

T(n)=  n
 T(n-2)+ +1 n>1
 2
n
T(n)=T(n-2)+ +1
2
 n-2  n n-2 n
T(n)=  T(n-2-2)+ +1 + +1=T(n-4)+ + +2
 2  2 2 2
 n-4  n-2 n n-4 n-2 n
T(n)=  T(n-4-2)+ +1 + + +2=T(n-6)+ + + +3
 2  2 2 2 2 2

n 2*i
k 1
T (n)  T (n  2 * k )  k 
i 0 2

n 1
T (1)  2 n 2*k 1 k 
2
n 1 n 3
1
n 1 2
n 2*i n 1 2
n 2*i
T (n)  T (n  2 *
2
)k  
i 0 2
 T (n  2 *
2
)k  
i 0 2
Primer Parcial Desarrollo Sistemático de Programas 2009

n 3
n 1 n 1 2
n 2*i
T (n)  T (n  2 *
2
)
2
 
i 0 2
n3
n 2 *
n 1 2
T (n)  T (n  (n  1))  
2 2
n 1 n  n  3
T (n)  T (1)  
2 2
n 1 3
T (n)  2  
2 2
n 1 7
T (n)  
2 2
1 1 7
T (n)  * n  
2 2 2
1 6
T (n)  * n 
2 2
1
T (n)  * n  3
2
//Principal
algoritmo NumerosImpares
variables
entero: N
inicio
leer N
si (N<0) entonces
escribir ‘El programa trabaja con número enteros’
sino
MostrarImparesI(N)
si (resto(N,2) = 0) entonces
MostrarImparesR(N-1)
sino
MostrarImparesR(N)
fin si
fin si
fin

Costo Total del procedimiento Iterativo:

//Costo del leer, si, llamada al procedimiento
3 3
T(n)= *n+2+3= *n+5 O(n)
2 2
Costo Total del procedimiento Recursivo:
//Costo del leer, si, resto, comparación, llamada al procedimiento
1 1
T (n)  *n35  *n8 O(n)
2 2
Es mejor el algoritmo recursivo.