Scribd
Cargar
492 vistas6 páginas

Informe Algoritmos

Este documento presenta un análisis de algoritmos iterativos realizado por tres estudiantes. El objetivo general fue analizar diferentes problemas usando algoritmos iterativos y medir sus tiempos de ejecución. Los objetivos específicos incluyeron verificar algoritmos iterativos, analizar sus tiempos de ejecución, expresar complejidad temporal y aprender sobre eficiencia. El proyecto determinó expresiones O para el tiempo de corrida de fragmentos de código y funciones, y expresó la complejidad temporal de fragmentos de programa en notación O.

Cargado por

Kevin Tulcán
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
492 vistas6 páginas

Informe Algoritmos

Este documento presenta un análisis de algoritmos iterativos realizado por tres estudiantes. El objetivo general fue analizar diferentes problemas usando algoritmos iterativos y medir sus tiempos de ejecución. Los objetivos específicos incluyeron verificar algoritmos iterativos, analizar sus tiempos de ejecución, expresar complejidad temporal y aprender sobre eficiencia. El proyecto determinó expresiones O para el tiempo de corrida de fragmentos de código y funciones, y expresó la complejidad temporal de fragmentos de programa en notación O.

Cargado por

Kevin Tulcán
Derechos de autor
© © All Rights Reserved
Nos tomamos en serio los derechos de los contenidos. Si sospechas que se trata de tu contenido, reclámalo aquí.
Formatos disponibles
Descarga como DOCX, PDF, TXT o lee en línea desde Scribd
Está en la página 1/ 6

UNIVERSIDAD CENTRAL DEL ECUADOR

FACULTAD DE INGENIERÍA Y CIENCIAS APLICADAS


Nombre de la Carrera
INFORME DE Nombre materia

Integrantes: Steven Solórzano, Edison Carlosama, Christopher Trujillo

Curso: Fecha:
ISI S4-P1 21/12/2020
Tema:
Análisis de algoritmos iterativos

Objetivo General
Analizar los diferentes problemas planteados, usando el concepto de algoritmos
planteados que se basa en llegar a un resultado a través de una iteración mediante un
ciclo definido o indefinido.

Objetivos Específicos
 Verificar diferentes algoritmos iterativos que poseen diferentes estructuras.
 Analizar y medir sus tiempos de ejecución considerando cada parte del
programa presentado.
 Lanzar resultados de complejidad temporal y expresar los tiempos de corrida de
peor caso.
 Aprender de los diferentes tiempos de ejecución y así lograr programas más
eficientes

Descripción del Proyecto


Determinar una expresión O para el tiempo de corrida de peor caso de cada
fragmento de código.
Para cada una de las funciones java en el documento, averiguar qué es lo que
calculan.
Expresar la respuesta como función de n. Expresar el tiempo de corrida de peor caso
en notación O.
Para cada fragmento de programa, encontrar la complejidad temporal expresada en
notación O.
Infraestructura del Computador
hp laptop 15-da2029la.
procesador Intel Core i7 2.3 ghz.
memoria Ram 16 Gb.
Windows 10 Home, 64 bits.
Alcance del Proyecto

1. Determinar una expresión O para el tiempo de corrida de peor caso de cada uno de
los siguientes fragmentos de código.
a) f(n, 10, 0);
g(n, m, k);
h(n, m, 1000000);
b) for (int i = 0; i < n; ++i)
f(n, m, k);
c) for (int i = 0; i < e(n, 10, 100); ++i)
f(n, 10, 0);
d) for (int i = 0; i < e(n, m, k); ++i)
f(n, 10, 0);
e) for (int i = 0; i < n; ++i)
for (int j = i; j < n; ++j)
f(n, m, k);
Suponer que n, m y k son de tipo entero, y que las funciones e, f, g y h tienen las
siguientes características:
• e(n, m, k) es O(1) y devuelve valores entre 1 y (n + m + k);
• f(n, m, k) es O(n + m);
• g(n, m, k) es O(m + k);
• h(n, m, k) es O(n + k).

Solución:

a) f(n, 10, 0); } O(n+10)


g(n, m, k); } O(m+k) O(n+1000000)
h(n, m, 1000000); } O(n+1000000)

Respuesta: O(n+1000000)

b) for (int i = 0; i < n; ++i) }O(n) O(n+m)


f(n, m, k); } O(n+m)

Respuesta: O(n+m)

c) for (int i = 0; i < e(n, 10, 100); ++i) } [O(1), O(n+10+100)]


f(n, 10, 0 ); } O(n+10) O(n+10+100)

Respuesta: O(n+10+100)
d) for (int i = 0; i < e(n, m, k); ++i) } [O(1), O(n+m+k)]
f(n, 10, 0); } O(n+10)} O(n+m+k)

Respuesta: O(n+m+k)

e) for (int i = 0; i < n; ++i) } O(n)^2


for (int j = i; j < n; ++j) } O(n) O(n)^2
f(n, m, k); } O(n+m)

Respuesta: O(n)^2

EJERCICIO 2

2.Para cada una de las siguientes funciones java, averiguar qué es lo que calculan,
Expresar la respuesta como función de n. Expresar el tiempo de corrida de peor caso
en notacion O

a)
Función que da como resultado una suma iterativa hasta n veces

int f (int n)
}
Int sum = 0; -Operación elemental----- Q (1)
For(int i; i <= n; i++) -En el peor de los casos se repetirá n veces------
Q (n . 1) = Q (n)
Sum+= i; -Operación elemental ---- Q(1)
Return sum; -Operación elemental---- Q(1)
}
Mayor de la secuencia de instrucciones Q(n)
Función tendrá una eficiencia de O(n)

b)

Función que da como resultado una suma iterativa entre el iterador y el valor de una
función hasta n-1 veces

int g (int n)
}
Int sum = 0; Operación elemental----- Q (1)
For(int i; i < n; i++) -En el peor de los casos se repetirá n -1 veces------
---Q ((n - 1.). n) = Q (n2 −n) = O( Max(n2 , n))= Q (n2 )
Sum += i + f(n); ---por orden de eficiencia de f(n) -----Q(n)
Return sum; -Operación elemental----- Q (1)
}

Mayor de la secuencia de instrucciones Q (n2 )


Función tendrá una eficiencia de Q (n2 )

c)
Función que da como resultado la suma del valor de la función f(n) con el valor de la
función g(n)

int h(int n)
}
Return f(n) + g(n) ----------Q (n2 ) + Q (n) = Q(n2 +n ) = O( Max(n2 , n)) = Q (n2 )
}

Función tendrá una eficiencia de Q (n2 )

3. Para cada uno de los siguientes fragmentos de programa, encontrar la complejidad


temporal expresada en notación O.

a) for (i = n; i >= 1; i /= 2) 1 asignaci ó n+ ( n4 +1 ) comparaciones + n4 decrementos


System.out.println("Increible\n"); n
1 goto en falso
3n
TOTAL: +3 Y SIMPLIFICANDO EN NOTACIÓN O TENEMOS QUE ESTE
2
ALGORITMO TIENE COMPLEJIDAD DE ORDEN O(n)

b) for (i = 1; i < n; i *= 2) 1 asignacion+( n+1)comparaciones +2 n incrementos


for (j = 1; j <= i; ++j) (3 n+2)∗n
System.out.println("Deberes\n"); n∗n
n goto en falso for j1 goto en falso for i
2
TOTAL: 4 n +6 n+3 Y SIMPLIFICANDO EN NOTACIÓN O TENEMOS QUE ESTE
ALGORITMO TIENE COMPLEJIDAD DE ORDEN O(n2 )

c) for (i = 1; i * i <= n; ++i) 1 asignacion+2 n+1 comparaciones+ 2 nincrementos


for (j = i; j >= 1; --j) (2 n+2)∗n
System.out.println ("Asignación\n") n∗n
n goto en falso for j
1 goto en falso for i
TOTAL: 3n2 +7 n+ 3 Y SIMPLIFICANDO EN NOTACIÓN O TENEMOS QUE ESTE
ALGORITMO TIENE COMPLEJIDAD DE ORDEN O(n2 )

Limitaciones

1. Se limitó hacer la comprobación de la eficiencia de ejecución del algoritmo en el


peor de los casos, es decir en el peor escenario posible en recursos
computacionales y no computacionales, en la que se pudo hacer una acotación
en el tiempo de ejecución del algoritmo
2. Al medir la eficiencia de los algoritmos se tomó en consideración las
limitaciones en hardware donde se realizaron las pruebas por lo que el
resultado en los tiempos de ejecución tiende a variar

Conclusiones y Recomendaciones

Conclusiones

 En conclusión, la complejidad algorítmica es una métrica que te permite como


programador evaluar la factibilidad de las diferentes soluciones de un problema,
y poder decidir con un argumento matemático cuál es mejor.
 Mejorar el tiempo de ejecución asintótica de un programa generalmente mejora
ostensiblemente su desempeño, mucho más que pequeñas optimizaciones
técnicas, tales como usar un lenguaje de programación más rápido.
 Dado un conjunto de bucles que son secuenciales, el más lento de ellos
determina el comportamiento asintótico del programa. Dos bucles anidados,
seguidos por un solo bucle, asintóticamente es lo mismo que los bucles
anidados por sí solos, ya que los bucles anidados dominan el bucle individual.
 Cualquier programa que carezca de bucles tendrá un O(1), ya que el número
de instrucciones que requiere es simplemente una constante, a menos que
utilice recursión.
 El análisis de programas sencillos se puede hacer contando los bucles que
contiene el programa. Un sólo bucle sobre n ítems genera O(n). Un bucle
dentro de otro bucle O(n2 ). Un bucle dentro de un bucle que está dentro de otro
bucle genera O(n3 ).
Recomendaciones

 Se recomienda no trabajar con en tiempo real de cómputo de un algoritmo ya


que ese es un factor que depende más que todo de las características de la
computadora en la que corre dicho algoritmo.
 Aunque es posible medir la complejidad algorítmica en función de las
operaciones que realiza un algoritmo, es mejor utilizar alguna notación que
permita efectuar comparaciones sencillas para valores de N grandes, del
tamaño del problema por resolver.
 Si bien todos los símbolos O, o, Ω, ω y Θ suelen ser útiles, la notación
asintótica O es el que comúnmente se recomienda usar más, ya que es más
fácil de determinar que Θ y de mayor valor práctico que Ω.
Bibliografía

Besembel, I. (2006). Diseño y Análisis de Algoritmos. Recuperado el 10 de 10 de 2011

Cardona, S., Jaramillo, S., & Carmona, P. (2007). Análisis de Algoritmos en Java. Armenia:
Elizcom.

Valenzuela, V. (2003). Manual de Análisis y Diseño de Algoritmos. Santiago, Chile

Hernández, L. (2004). Análisis de Algoritmos y Complejidad Computacional. Recuperado el 10


de 11 de 2011, de http://www.geocities.ws/leoher314/algorit.htm

Firma integrantes

Edison Carlosama Christopher Trujillo


1724977788 1751625284

Steven Solórzano
17500111114

También podría gustarte