Criterios de corrección y TEST AUTOMÁTICOS APLICADOS A LA TAREA 1

===================================================================================================================

La tarea es corregida automáticamente por un script que ejecuta una serie de casos de prueba.

Para cada ejercicio (función), si un caso de prueba falla, los siguientes no se ejecutan.

En algunos casos, como por ejemplo si no se sigue estrictamente el formato de la entrega, el script falla y la corrección debe realizarla una persona.

El script comienza asignando 3 puntos, 1 por cada función, y luego descuenta puntos a medida que los test fallan.

Función distHamming:

La función distHamming cuenta las posiciones de v1 y v2 que son distintas. 

Deben recorrerse todas las posiciones, por lo que hay que utilizar un for.

Antes de la recorrida se debe comprobar si los vectores son del mismo largo, y en caso contrario devolver -1 inmediatamente.

'Parámetros entrada de la función distHamming';

Comprueba si la función distHamming recibe 2 parámetros de entrada. Este test falla también cuando no se respetaron las instrucciones de la entrega y el formato de los archivos no es el esperado; por ejemplo, si se incluye código (no comentarios) antes del cabezal de la función.

Resta 1 punto, debido a que si este test falla los demás no pueden ejecutarse.

'Parámetros salida de la función distHamming';

Comprueba si la función distHamming tiene 1 parámetro de salida.

Resta 1 punto, debido a que si este test falla los demás no pueden ejecutarse.

'distHamming produce el resultado correcto';

Comprueba que la expresión "distHamming([3,2,1,4,5,7,3,2,1],[3,2,8,4,8,7,8,2,1])==3" es verdadera.

Resta 1 punto.

'distHamming: vectores iguales';

Comprueba que la expresión "distHamming([3,2,1,4,5,7,3,2,1],[3,2,1,4,5,7,3,2,1])==0" es verdadera.

Resta=0.25.

'distHamming: vectores de distinto largo';

Comprueba que la expresión "distHamming([3,2,1,4,5,7,3,2,1],[3,2,1,4,5])==-1" es verdadera.

Resta 0.25.

===================================================================================================================

Función encontrarMasParecido:

Para resolver esta función es aceptable utilizar distHamming.

Mientras no se encuentre en v1 una secuencia igual a v2 y queden posiciones de v1 por recorrer, se debe obtener la distancia entre v2 y v1(i:i + l2 - 1), donde i es la posición actual y l2 es el largo de v2.

En cada iteración se debe guardar la mínima distancia encontrada hasta el momento y la posición i correspondiente.

Al encontrar una secuencia en v1 con distancia 0 a v2 no tiene sentido continuar la búsqueda, por lo que el ejercicio debe resolverse con un while.

Antes de ejecutar los test se copia nuestra solución de la función distHamming para que esta pueda ser invocada por encontrarMasParecido aunque no haya sido bien resuelta.

Se realiza el chequeo de la cantidad de parámetros de entrada y salida al igual que en la función anterior.

Resta 1

'encontrarMasParecido produce el resultado correcto';

Ejecuta:

[pos,dist]=encontrarMasParecido([1,2,3,4,3,4,2,5,6,7,3,2],[3,4,4]);

eval_expr=(pos==3 && dist==1);

Luego comprueba que eval_expr es verdadera.

Resta 1

'encontrarMasParecido: vectores iguales'

Ejecuta:

[pos,dist]=encontrarMasParecido([3,2,1,4,5,7,3,2,1],[3,2,1,4,5,7,3,2,1]);

eval_expr=(pos==1 && dist==0);

Luego comprueba que eval_expr es verdadera.

Resta 0.5

'encontrarMasParecido: vector 2 más largo largo';

Comprueba si encontrarMasParecido retorna -1 en ambos parámetros cuando el vector en el que se busca es más corto que el vector buscado.

Resta 0.25;

'encontrarMasParecido: la función para al encontrar una secuencia igual?';

Este test busca comprobar si la función se resolvió utilizando un while que pare al encontrar una secuencia igual a la buscada.

Resta 0.25

===================================================================================================================

Función estaEnMatriz:

Esta función devuelve 1 si existe una secuencia (horizontal) en la matriz M igual a v. Puede usarse la función distHamming y parar al encontrar una secuencia de distancia 0.

Hasta encontrar una secuencia igual se deben obtener para cada posición de la matriz e=distHamming(M(i,j:j+lv-1),v)==0; donde i y j son la posición actual y lv es el largo de v; si e es 1 o se visitan todas las posiciones de la matriz el algoritmo termina. Por lo tanto, el ejercicio debe resolverse con dos while anidados, uno que recorre las filas de la matriz y otro que recorre las columnas hasta la columna ncol-lv+1, donde ncol es la cantidad de columnas de M.

Antes de ejecutar los test se copia nuestra solución de la función encontrarMasParecido para que esta pueda ser invocada por estaEnMatriz aunque no haya sido bien resuelta.

'estaEnMatriz.m: produce la salida correcta?':

Comprueba que la expresión "estaEnMatriz([1 2 3 4; 2 4 5 3],[3,4])==1" es verdadera.

Resta 1;

'estaEnMatriz.m: produce la salida correcta?';

Comprueba que la expresión "estaEnMatriz([1 2 3 4; 2 4 5 3],[1,1])==0"; es verdadera.

Resta 1;

'estaEnMatriz.m: para al encontrar una secuencia igual?';

Este test busca comprobar si la función se resolvió utilizando un while que pare al encontrar que la secuencia está en la matriz';

Resta 0.5;