Capítulo 2

1. Capítulo 2 Algoritmos

3. Lógica Complejidad Otra vez lógica

4. Definición de Algoritmo: Se define como un procedimiento constructivo para la resolución de un problema y consta de: • Datos de entrada (precisamente definidos), • una cantidad finita y ordenada de instrucciones que • aplicadas a los datos de entrada y después de realizar una cantidad finita de operaciones obtiene una solución del problema.

5. Resaltamos • Datos de entrada. • Operaciones básicas. • El algoritmo termina. • Hay que demostrar que resuelve el problema. • Hay que estudiar su eficiencia.

6. Modelo computacional • Determinar los tipos de datos que admite como entrada. • Determinar las operaciones básicas (y construidas por medio de ellas, más complejas) que puede hacer con dichos datos.

7. Nuestro Modelo ComputacionalRAM • Datos de entrada: números enteros. • Operaciones básicas: • Asignaciones: x:=2; • Operaciones de suma (+), resta (-), multiplicación (·, ×) y división entera (2/3, 2 mod 3). • Comparaciones (x < y, x>y, x ≥y, x≤y, x≠y, x=y)

8. Ejemplos Asignaciones x:=5 y:=3 Sumas: x+y (=8) Restas: x-y (=2) Cociente: x/y (=1) Resto: x mod y (=2) Comparaciones: x>y ≠ ≤ ≥ <

9. Instrucciones • Condicionales: • If (condición1, condición2,…) then (instrucciones 1) [else (instrucciones 2)] • If x>y then m:=x+y • Bucles: • For i=a to b (i empieza en a, termina en b y va de uno en uno) Instrucciones • While (condición) (el posible contador no cambia) Instrucciones

10. Máximo de dos números Entrada: a, b (dos números enteros) If a>b then m:=a else m:=b Salida: m

11. Máximo de una lista Entrada: a_1,…, a_n (una pequeña trampa) m:=a_1 For i=2 to n If a_i>m then m:=a_i Salida: m

12. Suma de los elementos de una lista Entrada: a_1,…, a_n Suma:=a_1 For i=2 to n Suma:=Suma+a_i Salida: Suma

13. Suma de los positivos Entrada: a_1,…, a_n Suma:=0 For i=1 to n If a_i>0 then Suma:=Suma+a_i Salida: Suma

14. Suma de los elementos de una lista entre dos posiciones fijadas Entrada: a_1, …, a_n; m, m’ (1≤m≤m’≤n) Suma:=0 For i=m to m’ Suma:=Suma+a_i Salida: Suma

15. Producto de los números pares de una lista Entrada: a_1, …,a_n Producto:=1 For i=1 to n If a_i mod 2=0 then Producto:=Producto*a_i Salida: Producto

16. Determinar si en una lista hay un múltiplo de 3 Entrada: a_1, …,a_n S:=1 (switch) i:=1 While S=1, i≤n if a_i mod 3=0 then S:=0 i:=i+1 If S=0 then r:=“Sí” else r:=“No” Salida: r

17. Determinar una lista con los múltiplos de tres de una lista dada Entrada: a_1, …,a_n j:=0 For i=1 to n if a_i mod 3 =0 then j:=j+1, b_j:=a_i If j=0 then r:=“No hay múltiplos de tres” else r:=b_i,…,b_j (ejercicio) Salida: r

18. Valor absoluto Entrada: a If a>0 then |a|:=a else |a|=-a Salida: |a|

19. Producto cartesiano Entrada: a_1, …, a_n; b_1, …, b_m k:=1 (el subíndice de la lista salida) For i=1 to n For j=1 to m producto_k:=(a_i,b_j) k:=k+1 Salida: producto_1, …, producto_(nxm)

20. Intercambiar dos variables Es necesario introducir una variable auxiliar Intercambiar(x,y) z:=x x:=y y:=z Esto está mal x:=y y:=x

21. Operaciones con listas • Borrar • Añadir • Concatenar • Sustituir • Mezclar

22. Borrar(L,i) Entrada: a_1, ..., a_n; i (1≤i ≤n) For j:= i to n-1 a_j:=a_(j+1) a_n:º=null Salida: a_1, …, a_(n-1)

23. Añadir(L,m,i) Entrada: a_1, ..., a_n; m; i (1≤i ≤n+1) k:=n+1 While k>i a_k:=a_(k-1) k:=k-1 a_i:=m Salida: a_1,…, a_(n+1)

24. Concatenar(L,L’) Entrada: a_1, ..., a_n; b_1, …, b_m For i=1 to m L:=Añadir(L,b_i,n+i) Salida: L

25. Sustituir(L,m,i) Entrada: a_1, ..., a_n; m; i (1≤i ≤n) a_i:=m Salida:a_1, …, a_n

26. Herramientas Asignaciones de listas L:=M elementos(L)=1 si L tiene algún elemento y 0 en caso contrario. Longitud(L)=n, esto es, el número de elementos que tiene una lista.

27. Mezclar(L,L’) Entrada: a_1, …, a_n; b_1, …, b_m (dos listas ordenadas) i:=0 (i es el subíndice de la salida) While elementos(L)*elementos(L’)=1 if min(L_1,L’_1)=L_1 then j:=0 else j:=1 i:=i+1, M_i:=min(L_1,L’_1), If j=0 then L:=Borrar(L,1) else L’:=Borrar(L’,1) If Longitud(L)>0 then M:=concatenar (M,L) else M:=concatenar(M,L’) Salida: M

28. Algoritmos de Búsqueda Problema: Dada una lista a_1, …, a_n y un número a, determinar si a es un elemento de la lista o no. Ejemplo: 5,7,8,-2,-3; 8 (la salida será sí) 2,4,5,-3,-7; 10 (la salida será no)

29. Búsqueda secuencial Entrada: a_1, …, a_n; a s:=0, i:=1 while i≤n, s=0 If a_i=a then s:=1 i:=i+1 If s=0 then r:=“No” else r:=“Sí” Salida: r

30. Búsqueda Binaria Entrada: a_1≤…≤a_n; a i:=1, j:=n, s:=0 (i y j representan los extremos inicial y final de la lista) While i<j,s=0 m:=(i+j)/2 If a_m=a then s:=1 else if a_m<a then i:=m+1 (cambia el extremo inicial) else j:=m-1 (cambia el extremo final) If s:=1 then r:=“Sí” else If a_((i+j)/2)=a then r:=“Sí” else r:=“No” Salida: r

31. Algoritmos de ordenación Problema: Dada una lista a_1, …, a_n ordenarla de menor a mayor (o al revés). Ejemplo: 3,-2,4,-7; -7,-2,3,4.

32. Algoritmo burbuja Idea: Comparara cada elemento con el siguiente, si están en el orden adecuado se dejan así, si no se intercambian sus valores. Al finalizar una “vuelta” el último ha ocupado su lugar. Recomenzamos con una lista de longitud una unidad menor, resultado de olvidar el último.

33. Ordenación burbuja Entrada: a_1, …, a_n For j=1 to n-1 (j es la vuelta en la que estamos) For i=1 to n-j (i es el contador de la lista) if a_i >a_(i+1) then x:=a_i a_i:=a_(i+1) a_(i+1):=x Salida: a_1, …, a_n

34. Algoritmo selección Usamos un algoritmo min que aplicado a una lista saca m, i. Donde m es el mínimo de la lista e i es el lugar que ocupa. (Ejercicio) Idea: si el mínimo no está en el primer lugar, intercambiamos el valor del primer lugar y el mínimo. Recomenzamos con una lista de longitud una unidad menor resultado de olvidar el primer elemento de la lista.

35. Algoritmo selección Entrada: L:=a_1, ..., a_n (asignación de listas) T:=L For j=1 to n-1 If min(T)_1 ≠a_j then L:=Intercambiar(L,j,min(T)_2+j-1) T:=Intercambiar(T,1, min(T)_2) T:=Borrar (T,1) Salida: L

36. Mínimo Entrada: L:=a_1, ..., a_n m_1:=a_1, m_2:=1 For i =2 to n if a_i<m_1 then m_1:=a_i, m_2:=i Salida: m_1, m_2

37. Borrar varios Entrada: L:=a_1, ..., a_n; 1≤b_1 ≤… ≤b_m ≤n i:=m While i>0 L:=Borrar(L,b_i) i:=i-1 Salida: L

38. Añadir varios Entrada: L:=a_1, ..., a_n; 1≤b_1 ≤… ≤b_m ≤n; c_1,…,c_m For i=1 to m L:=Añadir(L,b_i,c_i) Salida: L

39. Dividir con decimales Entrada: a,b; n a_0:=|a|/|b| r_0:=|a| mod |b| For i=1 to n a_i=10*r_(i-1)/|b| r_i:=10*r_(i-1) mod |b| If a*b>0 then r:=a_0’a_1...a_n else r:=-a_0’a_1…a_n Salida: r

40. Lista de los positivos Entrada: a_1, …, a_n j:=0 For i=1 to n if a_i>0 then j:=j+1, b_j:=a_i If j=0 then r:=”No hay positivos” else r:=b_1,…,b_j Salida: r

41. Lista de los mayores que m Entrada: a_1, …, a_n; m j:=0 For i=1 to n if a_i>m then j:=j+1, b_j:=a_i If j=0 then r:=”No hay” else r:=b_1,…,b_j Salida: r

42. Borrar los positivos Entrada: a_1, …, a_n j:=n While j>0 if a_j>0 then L:=Borrar(L,j) j:=j-1 If elementos(L)=0 then r:=“No queda nada” else r:=L Salida: r

43. Máximo del producto de dos elementos distintos Entrada: a_1, …, a_n M:=a_1*a_2 For i=1 to n-1 For j=i+1 to n if M<a_i*a_ j then M:=a_i*a_ j Salida: M

44. Máximo del producto de dos elementos distintos Entrada: a_1, …, a_n k:=0 For i=1 to n-1 For j=i+1 to n k:=k+1,b_k:=a_i*a_ j Salida: maximo(b_1,..,b_k)

45. Máximo de las diferencias de dos elementos de una lista Entrada: a_1, …, a_n M:=a_1-a_2 For i=1 to n For j=1 to n If M<a_i-a_j, i ≠j then M:=a_i-aj Salida: M

46. Real RAM (los datos son números reales)Alineados Entrada: a_1,a_2; b_1,b_2; c_1,c_2; If det(a_1-b_1,a_2-b_2,b_1-c_1,b_2-c_2)=0 then alineados:=1 else alineados:=0 Salida: alineados

47. Hay 3 puntos alineados Entrada: a_1=a_11, a_12; …, a_n=a_n1,a_n2 s:=1, i:=1, While s=1, i ≤ n-2, j:=i+1 while s=1, j ≤n-1 k:=j+1 while k ≤ n, s=1 if alineados(a_i,a_ j, a_k)=1 then s:=0 k:=k+1 j:=j+1 i:=i+1 Salida: s

48. Complejidad Objetivo: diseñar mecanismos para evaluar la eficiencia de un algoritmo. Parámetros que sería interesante controlar: • Espacio (unidades de memoria) • Tiempo (número de operaciones básicas) • En promedio • En el peor de los caso

49. Nuestra elección Controlar el tiempo. En el peor de los casos. Definición: Sea un algoritmo A que funciona sobre una entrada de tamaño n. Se define la función T(n) como el número de operaciones que realiza el algoritmo en el peor de los casos.

50. Dos observaciones • No hace falta ser muy exacto • T(n)=2n, T’(n)=2n+1, T’’(n)=2n^4 • Tampoco es fácil ser exacto Necesitamos un instrumento matemático que mida el carácter asintótico. No distinga T de T’ y sí de T’’