Instrucciones: En esta actividad vas a programar y determinar la complejidad de un algoritmo previamente escogido.

1. Considera el siguiente código para hacer ordenamientos

def algoritmo( entrada ) :

n = len( entrada )
for i in range( n-1 ):
smallidx = i
for j in range( i+1, n ):
if entrada[j] < entrada[smallidx]: smallidx = j

if smallidx != i:
tmp = entrada[i]
entrada[i] = entrada[ smallidx ]
entrada[smallidx] = tmp

2. Considera la siguiente situación. Cuando el diseño de las computadoras no estaba completamente estandarizado, algunas firmas
de electrónica (IBM, Motorola) leían el contenido de los bits en memoria de izquierda a derecha (big endian), y otros, como DEC, de
derecha a izquierda (little endian). Esto claramente causaba discrepancias graves a la hora de correr programas hechos para una y
otra máquina cuando el problema no es tan grave. De hecho, únicamente hay que leer una cadena de bytes en memoria en orden
invertido, sin olvidar que lo que tienes son cadenas de bytes, es decir, si en una máquina tienes la siguiente cadena, en una máquina
diseñada con el principio big endian
00110101 11010110 10110110 00111011
Debe ser leída en la máquina con little endian de la siguiente manera
10101100 01101011 01101101 110111100

3. Contesta las siguientes preguntas

a) ¿Cuál es la complejidad asociada al algoritmo recién presentado?
Cuando se tiene una serie de for anidados (m de ellos, por ejemplo), donde todos recorran un arreglo, este segmento de
algoritmo tendrá complejidad de 𝑂(𝑛𝑚 ).
(UnADM1, s.f., pág. 17)
 Por lo tanto para nuestro algoritmo presentado tenemos un for dentro de otro for, con lo cual tenemos que la complejidad del
algoritmo presentado es 𝑂(𝑛2 ) por ser la parte del código más compleja.
(GitHub, 2018)

b) Diseña un algoritmo que invierta los bytes en un tiempo 𝑂(𝑛2 ); (recuerda que la definición de 𝑂(𝑓(𝑛)) representa una cota
superior del orden de 𝑓(𝑛), es decir, el tiempo máximo que debería tomar al algoritmo ejecutarse).

Se propone el siguiente algoritmo para un conjunto de 4 bytes

Notemos que tenemos un for dentro de otro for (se remarcan con recuadro rojo en el código), con lo cual tenemos que la
complejidad del algoritmo presentado es 𝑂(𝑛2 ) por ser la parte del código más compleja.
c) Demuestra que log(6𝑛) = 𝑂 (log 𝑛), 3𝑛3 = 𝑂(𝑛4 ) y que 6𝑛2 + 2 ≠ 𝑂(𝑛)

Para log(6𝑛) = 𝑂 (log 𝑛) tomemos

log(6𝑛) ≤ 𝑐 ∙ log 𝑛 − − − (1)
Tomando 𝑛0 = 2 en
log(6𝑛0 ) ≤ 𝑐 ∙ log 𝑛0

log(6(2)) ≤ 𝑐 ∙ log 2

log(12)
≤𝑐
log 2
 3.58493 ≤ 𝑐
Con lo cual podemos dar 𝑐 = 4 en (1)
log(6𝑛) ≤ 4 ∙ log 𝑛

log(6) + log(𝑛) log(6) log(𝑛) log(6) 1 1 1

lim = lim + = lim + =0+ =
𝑛→∞ 4 ∙ log 𝑛 𝑛→∞ 4 ∙ log 𝑛 4 ∙ log 𝑛 𝑛→∞ 4 ∙ log 𝑛 4 4 4
Por lo tanto se cumple log(6𝑛) = 𝑂 (log 𝑛)

Para 3𝑛3 = 𝑂(𝑛4 ) tomemos

3𝑛3 ≤ 𝑐 ∙ 𝑛4 − − − (2)
Tomando 𝑛0 = 1 en
3𝑛03 ≤ 𝑐 ∙ 𝑛04

3≤𝑐
Con lo cual podemos dar 𝑐 = 3 en (2)
3𝑛3 ≤ 3 ∙ 𝑛4

3𝑛3 1
lim 4
= lim =0
𝑛→∞ 3𝑛 𝑛→∞ 𝑛
Por lo tanto se cumple 3𝑛3 = 𝑂(𝑛4 )

Para 6𝑛2 + 2 ≠ 𝑂(𝑛) supongamos posible

6𝑛2 + 2 ≤ 𝑐 ∙ 𝑛 − − − (3)
Tomando 𝑛0 = 1 en
6𝑛02 + 2 ≤ 𝑐 ∙ 𝑛0
 6+2≤𝑐

8≤𝑐
Con lo cual podríamos dar 𝑐 = 8 en (3)
6𝑛2 + 2 ≤ 8𝑛

6𝑛2 + 2 3𝑛 1
lim = lim + = ∞ 𝑒𝑠 𝑑𝑒𝑐𝑖𝑟 𝑙𝑎 𝑐𝑜𝑛𝑠𝑡𝑎𝑛𝑡𝑒 𝑐𝑟𝑒𝑐𝑒𝑟á 𝑐𝑎𝑑𝑎 𝑣𝑒𝑧 𝑚á𝑠
𝑛→∞ 8𝑛 𝑛→∞ 4 4𝑛

Por lo tanto no se cumple 6𝑛2 + 2 ≤ 𝑐 ∙ 𝑛 por lo que 6𝑛2 + 2 ≠ 𝑂(𝑛)

(UnADM1, 2015, págs. 10 y 11)