Práctica 11

Algoritmos

M.I. FCO. JAVIER RODRÍGUEZ, EDA I

Version 1.0, 25/11/21

Tabla de contenido
1. OBJETIVOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.1. Resultados de aprendizaje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2. Atributos de egreso CACEI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2. TEORÍA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1. Máximo en una lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.2. Búsqueda lineal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3. Números primos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.4. Divisores (factores) de un entero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.5. Búsqueda binaria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
3. ALGORITMOS VORACES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.1. Problema del cambio. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
3.2. Problema de la mochila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4. PROGRAMACIÓN DINÁMICA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.1. Problema del cambio (versión [WEISS]) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.2. Problema del cambio, (versión [BRASSARD97]) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
5. PRE-LABORATORIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
6. IN-LABORATORIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
6.1. Fuerza bruta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
6.2. Dividir y vencer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
6.3. Algoritmos voraces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
6.4. Programación dinámica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
7. POST-LABORATORIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
7.1. Fuerza bruta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
8. ENTREGABLES. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
9. BIBLIOGRAFÍA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
 Práctica 11

1. OBJETIVOS
Al finalizar la práctica:

1. Habrás programado diversos algoritmos de fuerza bruta en C y Python.

2. Habrás programado diversos algoritmos de búsqueda lineal en C y Python.

1.1. Resultados de aprendizaje

1
 1.2. Atributos de egreso CACEI

Resultado Sub-resultado Aplicación

1.2 Conocimiento y comprensión de las

disciplinas de ingeniería propias de su
Algoritmos de fuerza
1. Conocimiento especialidad, en el nivel necesario para
bruta, dividir y vencer, y
y comprensión adquirir el resto de las competencias del
voraces.
título, incluyendo nociones de los últimos
adelantos.

2.2 La capacidad de identificar, formular y

resolver problemas de ingeniería en su
especialidad; elegir y aplicar de forma
Resuelve problemas
2. Análisis en adecuada métodos analíticos, de cálculo y
utilizando la técnica más
Ingeniería experimentales ya establecidos; reconocer la
conveniente.
importancia de las restricciones sociales, de
salud y seguridad, ambientales, económicas e
industriales.

1.2. Atributos de egreso CACEI

Atributo Sub-atributo Aplicación

A1-CD2 Expresa el fenómeno

asociado mediante un modelo Pseudocódigos.
A1. Identificar, formular y
matemático adecuado.
resolver problemas de
Ingeniería en Computación
aplicando las ciencias básicas A1-CD3 Aplica la técnica
y los principios de la correspondiente de la Programación en un lenguaje
ingeniería. ingeniería para la resolución de computadora.
del problema.

2
 Práctica 11

2. TEORÍA

2.1. Máximo en una lista

// devuelve el valor máximo en la lista

maximo( list, elems ): Real
{
max = lista[ 0 ]
i = 1

Mientras i < elems

{
Si lista[ i ] > max ①
{
max = lista[ i ]
}

++i
}

Devuelve max
}

① JAMÁS USAR == CON NÚMEROS REALES: ¿1.0/3.0 == 0.3333?

3
 2.2. Búsqueda lineal

2.2. Búsqueda lineal

// Avisa si el valor sí está en la lista o no

blineal( list[], elems, key ): Bool
{
encontrado = false
i = 0;

Mientras i < elems AND encontrado = False

{
Si list[ i ] = key
{
encontrado = True
}

i = i + 1
}

Devuelve encontrado
}

4
 Práctica 11

2.3. Números primos

Listado 1. Versión 1

primos( n )
{
c = 2

Mientras c <= n
{
es_primo = True

j = 2

Mientras j < c
{
residuo = c MOD j

Si residuo = 0 { es_primo = False }

j = j + 1
}

Si es_primo = True { Print( c ) }

c = c + 1
}
}

5
 2.3. Números primos

Listado 2. Versión 2

primos( n )
{
c = 2

Mientras c <= n
{
Si test_primalidad( c ) = True { Print( c ) }

c = c + 1
}
}

test_primalidad( c )
{
es_primo = True

j = 2

Mientras j < c
{
residuo = c MOD j

Si residuo = 0 { es_primo = False }

j = j + 1
}

Devuelve es_primo
}

6
 Práctica 11

2.4. Divisores (factores) de un entero

El siguiente pseudo código imprime todos los divisores de un número entero natural, n:

Divisores( p )
{
c = 1

Mientras c <= p
{
Si (p MOD c) = 0 { Print( c ) }

c = c + 1
}
}

El siguiente pseudo código guarda en una lista todos los divisores de un número entero
natural, n:

Divisores( p, list )
{
c = 1
i = 0

Mientras c <= p
{
Si (p MOD c) = 0
{
list[ i ] = c
i = i + 1
}

c = c + 1
}

Devuelve list ①
}

① El concepto de devolución depende del lenguaje en el que el algoritmo es implementado.

En el caso de C no se devuelve nada ya que el arreglo fue pasado por referencia (es decir,
el original); en el caso de Python la lista se crea dentro del algoritmo y se devuelve.

7
 2.5. Búsqueda binaria

2.5. Búsqueda binaria

// Devuelve el índice del elemento donde haya encontrado, si alguna, la primer ocurrencia.
bbinaria( list[], elems, key ): Int
{
inf = 0
sup = elems - 1

Mientras inf <= sup

{
centro = (sup + inf) / 2

Si list[ centro ] = key

{
Devuelve centro
}
En caso contrario
{
Si key < list[ centro ]
{
Si sup = inf { Devuelve -1 }

sup = centro - 1
}
En caso contrario
{
inf = centro + 1
}
}
}

Devuelve -1
}

8
 Práctica 11

3. ALGORITMOS VORACES

3.1. Problema del cambio

cambio_voraz( cand[], p ): Sol[]

{
acum = 0
i = 0
sol[] = {0}

Mientras i < cand.len AND acum < p

{
x = cand[i]
Si (acum+x) <= p
{
sol.push_back( x )
}

i = i + 1
}

Si acum != p
{
sol={0}
}

Devuelve sol
}

3.2. Problema de la mochila

9
 4. PROGRAMACIÓN DINÁMICA

mochila_voraz( objetos: [], peso_max: Int ): Sol[]

{
peso_actual = 0
sol[]= {0}

Mientras peso_actual < peso_max

{
i = selección( objetos )

Si peso_actual + objetos[i].w <= peso_max

{
sol.push_back( (objetos[i].w * 1.0, objetos[i].v * 1.0) )
peso_actual = peso_actual + objetos[i].w
}
CC
{
fracc = ( peso_max - peso_actual ) / objetos[i].w
sol.push_back( (objetos[i].w * fracc, objetos[i].v * fracc) )
peso_actual = peso_max
}
}

Si peso_actual < peso_max

{
sol={0}
}

Devuelve sol
}

4. PROGRAMACIÓN DINÁMICA

4.1. Problema del cambio (versión [WEISS])

Éste es la versión en pseudo código del algoritmo presentado en [WEISS], el cual está
codificado en Java.

10
 Práctica 11

make_change( coins[], diff_coins, max_change ): coins_used[], last_coin[]

{
coins_used[] = {0}
last_coin[] = {0}

coins_used[0] = 0
last_coin[0] = 1

cents = 1
While cents <= make_change
{
min_coins = cents
new_coin = coins[0]

For each coin in coins

{
If coin <= cents
{
If coins_used[cents-coin]+1 < min_coins
{
min_coins = coins_used[cents-coin]+1
new_coin = coin
}
}
}

coins_used[ cents ] = min_coins;

last_coin[ cents ] = new_coin;

cents = cents + 1
}

return ( coins_used, last_coin )

}

4.2. Problema del cambio, (versión [BRASSARD97])

Éste es una transcripción (con una ligera adaptación) del algoritmo presentado en
[BRASSARD97, pp. 297].

11
 4.2. Problema del cambio, (versión [BRASSARD97])

/*
Devuelve el mínimo número de monedas necesarias para cambiar N unidades. El vector d[0..n-1]
especifica las denominaciones: en el ejemplo hay monedas de 1, 4 y 6 unidades (n=3).
*/
función monedas( N )
{
vector d[] = [1,4,6]
matriz c[0..n-1, 0..N]

para i = 0 hasta n-1

{
c[i,0] = 0
}

para i = 0 hasta n-1

{
para j = 1 hasta N
{
Si i = 0 AND j < d[0]
{
c[i,j] = INF
}
CC Si i = 0
{
c[i,j] = 1 + c[ 0, j - d[0] ]
}
CC Si j < d[i]
{
c[i,j] = c[ i-1, j ]
}
CC
{
c[i,j]= MIN( c[i-1, j], 1 + c[i, j-d[i] ] )
}
}
}

Devuelve c[n,N]
}

12
 Práctica 11

5. PRE-LABORATORIO
Intenta realizar en tu casa todos los ejercicios de la sección IN-LABORATORIO para que el día
de la práctica llegues con dudas.

(2022-1): Ya realizaste las secciones Fuerza bruta y Dividir y vencer, por lo que deberás
concentrarte en los algoritmos voraces y de programación dinámica.

13
 6. IN-LABORATORIO

6. IN-LABORATORIO
Realiza los programas indicados. Para todos ellos utiliza, cuando sea necesario, los valores
vistos en clase. Donde esté indicado, n será un valor introducido por el usuario del programa.

Cada ejercicio lo deberás realizar tanto en C como en Python.

6.1. Fuerza bruta

1. Búsqueda lineal de un valor key en una lista de números enteros.

2. Búsqueda del valor máximo en una lista de números reales.

3. Llenar una lista con todos los números primos hasta n.

4. Llenar una lista con todos los factores primos de un valor entero n.

6.2. Dividir y vencer

1. Búsqueda binaria de un valor key en una lista de números enteros.

6.3. Algoritmos voraces

1. Problema del cambio.

2. Problema de la mochila.

a. Maximizando el valor.

b. Maximizando la razón valor/peso.

6.4. Programación dinámica

1. Problema del cambio, versión [WEISS].

2. Problema del cambio, versión [BRASSARD97].

7. POST-LABORATORIO

7.1. Fuerza bruta

1. Llena una lista con los primeros n términos de la serie de Fibonacci. Utilice un algoritmo
secuencial (basado en ciclos). Por ejemplo, si n=8, entonces S={0,1,1,2,3,5,8,13}, para

14
 Práctica 11

toda 1⇐ n ⇐ 51. ¿Porqué 51?

2. Calcula el factorial de un número n. Por ejemplo, si n=5, entonces 5! = 120 = 5*4*3*2*1.

(Estos ejercicios son importantes de cara al tema de recursión.)

1. Para ambas versiones de programación dinámica escribe la segunda parte del algoritmo,
es decir, aquella parte que indica las monedas a entregar. Guarda dichas monedas en un
arreglo para que posteriormente lo imprimas.

8. ENTREGABLES
Están especificados en la HdT.

9. BIBLIOGRAFÍA
[AHO98]
Aho, Alfred V.; Hoptcroft, John E.; Ullman, Jeffrey D. Estructuras de datos y algoritmos.
Adisson Wesley. MÉXICO: 1998.

(El resto de la bibliografía la recibirás en un documento anexo.)

Referencia del lenguage C

http://www.cplusplus.com/reference/

15