CORPORACION UNIVERSITARIA IBEROAMERICANA

Actividad 3 - Algoritmos - Taller de práctica

Denisee Katherine
Rodríguez Guerrero
Matemáticas Discreta
2022
 1. Detectando la moneda falsa. Se tienen n monedas y se sabe que una de ellas es falsa (las
otras n− 1 son auténticas). La moneda falsa pesa ligeramente menos que las otras y
todas las auténticas pesan lo mismo. Se tiene una balanza que puede comparar el peso
de dos objetos, pero sólo indica si los pesos son iguales o cual es mayor de los dos.
Determine un procedimiento para detectar la moneda falsa, tratando de minimizar el
número de veces que se hace una comparación en la balanza. Sugerencia: Recuerde el
uso de la búsqueda binaria. ¿Cuál es la solución de esta recurrencia?
Solución:
Se forman dos grupos de ⌊n/2⌋ monedas, quedando una aparte si n es impar. Se comparan los
pesos de los dos grupos. Si los pesos son distintos entonces el grupo más ligero tiene la moneda
falsa y se puede proceder recursivamente con ese grupo. Si los pesos son iguales, esto solo
puede suceder si n es impar y entonces la moneda falsa es la que se puso aparte.
2. Considere el siguiente segmento de pseudocódigo
1. 1. k←1
2. 2. Para i←1 a n
3. 3. Para j←1 a i
4. 4. Para k←k + 1
Donde n tiene inicialmente un valor que es entero positivo. Determine con una buena precisión
el valor de k al finalizar la ejecución del segmento
Solución:
k se incrementa en cada iteración del para interior, y este se realiza i veces en i-ésima iteración
del para exterior por lo tanto el numero total de incrementos en k será:
0+1+2…+n= 1/2n(n+1)

3. Considere el siguiente segmento de pseudocódigo

1. 1. k←0
2. 2. Mientras n > 1
3. 3. k←k + 1
4. 4. n←⌊ n/2⌋
Solución:
Valores de k

N 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
k 0 1 1 2 2 2 2 3 3 3 3 3 3 3 3 4 4
Si n es una potencia de 2, n =2𝑃, entonces k=ℓ=log2 𝑛 al finalizar se necesita dividir ℓ veces a 2𝑃
por 2 par que ya no se tenga n>1. en otro caso existe un ℓ tal que 2𝑃−1 < n <2𝑃 y queremos
verificar que k = ℓ - 1, lo que es igual a ⌊log2 𝑛⌋: se tiene que que al dividir por 2 y tomar el el
piso se pasa al siguiente intervalo de 2:

2𝑃−1 ≤⌊n/2⌋<2𝑃−1
Al iterar división por 2 y piso, mientras no se tenga igualdad en el lımite inferior se pasa al
siguiente intervalo de potencias de 2. Eventualmente se debe tener la igualdad con el lımite
inferior porque si 20 ≤ x < 21 , se debe tener que x = 1. (Por ejemplo, veamos la iteración para
31: 16 < 31 < 32, 8 < 15 < 16, 4 < 7 < 8, 2 < 3 < 4, 2 ≤ 2 < 4.) Una vez se llega al límite inferior del
intervalo (una potencia de 2), cada división por 2 y piso reduce la potencia por 1, como en el
caso inicial ya analizado. Por lo tanto, el numero de veces que se incrementa k es el mismo que
para 2𝑃−1 , ó sea ℓ − 1.
Alternativamente, podemos plantear una ecuación de recurrencia
𝑎𝑛 = a⌊n/2⌋ + 1
con caso base 𝑎1= 0. Esta es igual a la ecuación de recurrencia de la busqueda binaria, pero con
caso base 𝑎1 = 0 (allá se tiene 𝑎1 = 1). La solución es como allá, menos 1, lo cual es ⌊=log2 𝑛⌋
4. La función “Incógnita” en el siguiente pseudocódigo tiene una variable a que es un entero no
negativo y una variable d que es un entero positivo. La función devuelve un par (x,y).
INCOGNITA (a, d)
1. si a < d
2. devolver (0, a)
3. si-no

4. (q; r) ← INCOGNITA (a – d, d)
5. devolver (q + 1, r)
a. Determine qué devuelve la función “Incógnita” para el par (a, d) igual a (15,4) y (28,5).

Solución:
Solución: Incógnita (15, 4), por ser “15 < 4” falso, evalúa recursivamente Incógnita (11, 4) en la
línea 4, esta evaluación recursiva a su vez evalúa Incógnita (7, 4), y a su vez Incógnita´ (3, 4);
este último, por ser “3 < 4” verdadero, devuelve (0, 3), que se convierte en (1, 3), (2, 3) y (3, 3)
respectivamente al concluir las anteriores evaluaciones recursivas. La siguiente tabla resume lo
que sucede, con la flecha indicando el “flujo de la computación”: en la columna “(a, d)” se lista
el par de parámetros de la correspondiente evaluación recursiva, y en “devuelve” se lista el par
devuelto en la línea 5
b. Qué función de a y d se está implementando
Solución
Se observa que la función Incógnita ´ (a, d) evalúa el cociente y residuo de dividir a por d.
Verifiquemos esto por inducción sobre a:

Base: Si a < d entonces el algoritmo correctamente devuelve cociente 0 y

residuo a.
Paso de inducción: Supongamos a ≥ d, entonces el algoritmo evalúa recursivamente Incognita ´
(a − d, d). Por hipótesis de inducción, esta evaluación devuelve el cociente q y residuo r de
dividir a − d por d,
es decir:
a − d = qd + r
con 0 ≤ r < d. Pero entonces

a = (q + 1)d + r,
es decir, el cociente de dividir a por d es q + 1 y el residuo es r. Estos valores son precisamente
los que Incógnita ´ (a, d) devuelve. Por lo tanto Incógnita ´ (a, d) evalúa correctamente el
cociente y residuo de
dividir a por d.

5. La función “Ordenamiento” en el siguiente pseudocódigo contiene un

Arreglo A de elementos para ser ordenados.
1. si i + 1≥j
2. si A [i] > A [j]
3. Intercambie A [i]↔A [j]
4. Devolver ()
3 k←⌊(k − i + 1)/3⌋
5. Ordenamiento (A, i, j − k)
4 Ordenamiento (A, i + k, j)
6. Ordenamiento (A, i, j − k)
Solución:

a. Describa lo que hace cada línea en el código

El algoritmo mantiene en cada llamada recursiva la propiedad de que si K está en la lista.

Por esto devuelve-1 en la línea 1, si i > j (ya no es posible que K este en L). El bloque del sí
(líneas 4-6) se encarga de que se mantenga este invariante a la siguiente llamada recursiva:
para esto elimina la \mitad" del rango que no puede contener K.

b. Muestre la operación de ordenamiento ([4, 8, 3, 2, 5, 1], 0, 5)

var indexOfMinimum = function(array, startIndex) {

// Set initial values for minValue and minIndex,
// based on the leftmost entry in the subarray:
var minValue = array[startIndex];

var minIndex = startIndex;

for (var i = startIndex + 1; i < array.length; i++) {

if (array[i] < minValue) {
minIndex = i;
minValue = array[i];
}

// Loop over items starting with startIndex,

// updating minValue and minIndex as needed:

return minIndex;
};

var array = [4, 8, 3, 2, 5, 1, 0, 5];

var index = indexOfMinimum(array, 2);

// For the test array [4, 8, 3, 2, 5, 1, 0, 5],

// the value 9 is the smallest of [.. 3, 2, 5, 1, 0, 5]
// Since 9 is at index 4 in the original array,
// "index" has value 4
println("The index of the minimum value of the subarray starting at index 2 is " + index + "." );
Program.assertEqual(index, 4);
Program.assertEqual(indexOfMinimum(array, 0), 1);
Program.assertEqual(indexOfMinimum(array, 4), 4);
c. Se podría cambiar ⌊(k − i + 1)/3⌋ por ⌈(k − i + 1)/3⌉ =
Si se podría ya que no afectaría en nada la función original.
d. Escriba una recurrencia para el número de comparaciones
Realizadas por el algoritmo con entrada de longitud n (no es
Necesario resolverla

Ejemplo
Algoritmo 1:
T(n) = 10 T(n) = 10-4 2n segundos
n = 38 datos
T(n) = 1 año

Algoritmo 2:
T(n) = 10 T(n) = 10-2 n3 segundos
n = 1000 bits
T(n) = 1 año