Durante esta actividad, los alumnos serán capaces de:
Esta actividad promueve las siguientes habilidades, valores y actitudes: análisis y síntesis, capacidad de resolver problemas, creatividad, y uso eficiente de la informática y las telecomunicaciones.
Esta actividad puede ser elaborada de manera individual o en parejas.
Usando el lenguaje de programación Java versión 7, escribe los métodos que se describen a continuación. Coloca todos los métodos en una clase pública llamada Searches dentro de un paquete llamado tc1018.util. En la parte superior del archivo coloca en comentarios los datos personales de los autores de la tarea. Por ejemplo:
/*-------------------------------------------------------------------- * Actividad de programación: Búsquedas * Fecha: 17-Feb-2013 * Autores: * 1166611 Pepper Pots * 1160611 Anthony Stark *--------------------------------------------------------------------*/
Prueba tu código usando la clase TestSearches.java de JUnit.
public static <T> List<Integer> indexesOf(List<T> list, T obj)
Devuelve una lista de enteros que contiene todos los índices en donde obj aparece en list. Devuelve una lista vacía si obj nunca aparece en list.
Prueba de unidad:
@Test
public void testIndexesOf() {
List<String> emptyList = Arrays.asList();
List<String> list1 = Arrays.asList("a", "b", "a", "c", "d", "a", "e");
List<Integer> list2 = Arrays.asList(4, 8, 15, 16, 23, 42);
assertEquals(Arrays.asList(0, 2, 5), Searches.indexesOf(list1, "a"));
assertEquals(Arrays.asList(5), Searches.indexesOf(list2, 42));
assertEquals(emptyList, Searches.indexesOf(list1, "x"));
assertEquals(emptyList, Searches.indexesOf(emptyList, "a"));
}
public static <T> T mostRepeated(List<T> list)
Devuelve el elemento que aparece el mayor número de veces en list. Si hay un empate entre varios elementos, entonces devuelve el que aparece primero. Devuelve null si list está vacía.
Prueba de unidad:
@Test
public void testMostRepeated() {
List<String> emptyList = Arrays.asList();
List<String> list1 = Arrays.asList("a", "b", "a", "c", "d", "a", "e");
List<String> list2 = Arrays.asList("f", "g", "h", "i", "j");
List<Integer> list3 = Arrays.asList(42);
assertNull(Searches.mostRepeated(emptyList));
assertEquals("a", Searches.mostRepeated(list1));
assertEquals("f", Searches.mostRepeated(list2));
assertEquals(new Integer(42), Searches.mostRepeated(list3));
}
public static <T> int mostRepeatedFrequency(List<T> list)
Devuelve la cantidad de veces que se repite el elemento más repetido de list. Devuelve cero si list está vacía.
Prueba de unidad:
@Test
public void testMostRepeatedFrequency() {
List<String> emptyList = Arrays.asList();
List<String> list1 = Arrays.asList("a", "b", "a", "c", "d", "a", "e");
List<String> list2 = Arrays.asList("f", "g", "h", "i", "j");
List<Integer> list3 = Arrays.asList(42);
assertEquals(0, Searches.mostRepeatedFrequency(emptyList));
assertEquals(3, Searches.mostRepeatedFrequency(list1));
assertEquals(1, Searches.mostRepeatedFrequency(list2));
assertEquals(1, Searches.mostRepeatedFrequency(list3));
}
public static <T> List<T> allMostRepeated(List<T> list)
Similar al problema 2, pero este método devuelve una lista con el elemento que más veces se repite en list. Si hay un empate entre varios elementos, entonces éstos también se incluyen en la lista resultante. Devuelve una lista vacía si list está vacía.
Prueba de unidad:
@Test
public void testAllMostRepeated() {
List<String> emptyList = Arrays.asList();
List<String> list1 = Arrays.asList("a", "b", "a", "c", "d", "a", "e");
List<String> list2 = Arrays.asList("a", "b", "a", "c", "a", "c", "c");
List<Integer> list3 = Arrays.asList(4, 8, 15, 16, 23, 42);
List<Integer> list4 = Arrays.asList(42);
assertEquals(emptyList, Searches.allMostRepeated(emptyList));
assertEquals(Arrays.asList("a"), Searches.allMostRepeated(list1));
assertEquals(Arrays.asList("a", "c"), Searches.allMostRepeated(list2));
assertEquals(Arrays.asList(4, 8, 15, 16, 23, 42),
Searches.allMostRepeated(list3));
assertEquals(Arrays.asList(42), Searches.allMostRepeated(list4));
}
public static <T extends Comparable<? super T>> int iterativeBinarySearch(List<T> list, T obj)
Tiene la misma funcionalidad que recursiveBinarySearch (que se verá en clase próximamente) pero sin usar recursión. Es decir, se debe usar el mecanismo de iteración convencional (por ejemplo un ciclo while) en lugar de llamadas a sí misma (recursivas). En este caso no se requiere definir una función auxiliar. Solo es necesario definir start y end como variables locales inicializadas con sus valores correspondientes. El ciclo termina cuando se encuentra el elemento buscado o cuando start > end. El cuerpo del ciclo consiste en actualizar las variables start o end según lo determinen las comparaciones que se vayan realizando.
Prueba de unidad:
@Test
public void TestIterativeBinarySearch() {
List<String> emptyList = Arrays.asList();
List<String> list1 = Arrays.asList("a", "b", "c", "d", "e", "f", "g");
List<Integer> list2 = Arrays.asList(4, 8, 15, 16, 23, 42);
assertEquals(-1, Searches.iterativeBinarySearch(emptyList, "a"));
int i = 0;
for (String s: list1) {
assertEquals(i, Searches.iterativeBinarySearch(list1, s));
i++;
}
assertEquals(-1, Searches.iterativeBinarySearch(list1, "x"));
i = 0;
for (int x: list2) {
assertEquals(i, Searches.iterativeBinarySearch(list2, x));
i++;
}
assertEquals(-1, Searches.iterativeBinarySearch(list2, 0));
}
Sube el archivo Searches.java usando el Sistema de Entrega de Tareas Automatizado. No se aceptan tareas por ningún otro medio.
Fecha límite: Domingo, 17 de febrero.
Esta actividad será evaluada usando los siguientes criterios:
| 100 | La actividad cumple con todos los requerimientos. |
|---|---|
| -10 | No se incluyó en comentario los datos de los autores. |
| 10 | El programa fuente no compila. |
| 50-90 | El programa produce algunos errores al momento de correrlo. |
| DA | La solución es un plagio. |