← Volver a los ejercicios

alReves: arme la llamada que delata el error

Aquí no hay nada escondido: las tres versiones están a la vista y dos de ellas tienen un error. Lo que hay que construir es la llamada de prueba. Se eligen f, prox y el rango, se corre, y la tabla dice si cada versión con error quedó al descubierto o entregó el mismo número que la buena. Una de las dos se cae con cualquier llamada; la otra solo con algunas.

1. Las tres versiones

def suma(f: Int => Int, prox: Int => Int, a: Int, b: Int): Int =
if (a > b) 0 else f(a) + suma(f, prox, prox(a), b)
def sumaSinProx(f: Int => Int, prox: Int => Int, a: Int, b: Int): Int =
if (a > b) 0 else f(a) + sumaSinProx(f, prox, a + 1, b)
def sumaBaseUno(f: Int => Int, prox: Int => Int, a: Int, b: Int): Int =
if (a > b) 1 else f(a) + sumaBaseUno(f, prox, prox(a), b)

sumaSinProx recibe prox y no lo usa: avanza siempre de uno en uno. sumaBaseUno cierra con 1 en lugar de 0. Las dos compilan y las dos devuelven un número.

2. Arme una llamada que atrape a las dos

llamadasumasumaSinProxsumaBaseUno¿atrapa a sumaSinProx?¿atrapa a sumaBaseUno?
llamadas corridas: 0 de 48 posibles

3. ¿Por qué con prox = x => x + 1 el error de sumaSinProx no aparece nunca?

4. Lo que se lleva de aquí

El error de sumaBaseUno se ve con cualquier llamada: el 1 de más aparece siempre, porque el caso base se alcanza una vez y solo una. El de sumaSinProx necesita dos condiciones al tiempo: un prox distinto de x => x + 1 y un rango con más de un término. Con (1, 1) las dos recorren un solo término y dan lo mismo, por bien elegido que esté prox.

Una prueba escrita con los valores más cómodos —x => x, x => x + 1, un rango corto— pasa en verde con las tres versiones. Es lo que se pide en las pruebas de los talleres: entradas que separen versiones, no entradas que las confundan.

Ir a literales: qué hace cada literal →