Java arrays o arreglos cual es la mayor serie de repeticiones de número utils

[alfredoDSK]

Hola, soy un estudiante de universidad y me han puesto unos ejercicio que no sé cómo atacar y me gustaria saber si me pueden ayudar aqui. A continuacion los ejercicios:

1.Calcular el numero máximo de ocurrencias consecutivas de un elemento en un array.
Se pide implementar el método

static int maxNumRepeated(Integer[] array, Integer elem)

dentro la clase Utils que recibe un array de enteros array y un Integer elem, y devuelve el numero máximo de ocurrencias consecutivas de elem en array.

El código que yo he creado es el siguiente:

Código: [Seleccionar]

public class Utils {

  public static int maxNumRepeated(Integer[] a, Integer elem)  {
      // Hay que modificar este metodo
 
  int contador=0;
 
  for(int i=0; i<a.length; i++){ //recorro el array
 
 
 
  if(a[i]==elem){  //si la posicion i del array igual a elem
  for(int j=i; j<a.length; j++){  //recorro empezando por i
  int aux=0;  //creo un auxiliar
  if(a[j].equals(elem)){  //condicion
  aux++;  //aumento auxiliar
  }
  else{  //comparaciones aux y contador
  if(aux>contador) {
  contador=0;
  contador=aux;
  }
  }
  aux=0;
  }
  }
  }
  return contador;
  }
 }
Pero en los test me salta error.

El segundo ejercicio es el siguiente:

2.Borrar elementos repetidos en una lista indexada.

Se pide implementar el método

static <E> IndexedList<E> deleteRepeated(IndexedList<E> l)

dentro la clase Utils.

Recibe una lista indexada, y devuelve una nueva lista donde los elementos repetidos dentro de l han sido borrados.

El orden de elementos en l debe preservarse en el resultado.

No se debe modificar la lista de entrada l.

Y este no sé ni cómo atacarlo ya que las listas indexadas no las domino muy bien.

Si alguien pudiera ayudar lo agradeceria mucho.

Un saludo

[Kabuto]

Hola.

Lo primero, aclarar que esta seccion es para presentarse y saludar a la comunidad.
Para pedir ayuda hay otras secciones.
De todos modos, no te preocupes, algun moderador lo moverá a su sitio.

Sobre tu consulta.
Con el primer ejercicio sí te puedo ayudar. Con el segundo me temo que no, porque yo tampoco estoy nada familiarizado con las IndexedList 
Aunque luego miraré a ver que puedo aprender de ellas.

El primer ejercicio.
Al margen de algún pequeño olvido como el indicado en rojo:

if(a[ i ]==elem){  //si la posicion i del array igual a elem

en realidad casi lo consigues, pero lo has complicado más de lo necesario. No hace falta usar bucles anidados. Con un solo bucle recorriendo el array es suficiente.

Mira te dejo aquí una clase con el método escrito y un pequeño main() para ponerlo a prueba.
Incluye comentarios largos para que se entienda mejor lo que hace el código.

public final class Test {
   
   public static int maxNumRepeated(Integer[] a, Integer elem) {
      int contador = 0;
      int maxConsecutiva = 0;
      
      for (int i=0; i<a.length; i++)
         if (a[ i ].equals(elem)) {//Ocurrencia, contamos
            contador++;
            }
         }
         else {//No hay ocurrencia. Aquí tenemos dos posibles escenarios.
            
            /*
             * Escenario (1). NO estabamos contando porque en este momento no habían ocurrencias.
             * Podemos saber que estamos en este escenario si contador == 0.
             * En cualquier caso, en este escenario no tenemos que hacer nada de nada, así que ni
             * siquiera vamos a preguntar por el valor de contador. Simplemente dejamos que el bucle
             * siga su curso.
             */
            
            /*
             * Escenario (2). SÍ estabamos contando porque estabamos dentro de una serie de ocurrencias.
             * Podemos saber que estamos en este escenario si contador > 0.
             * En este escenario, tenemos que averiguar si esta serie de ocurrencias consecutivas (que ya ha
             * terminado puesto que ahora ya han dejado de haber ocurrencias), hay que ver si es mayor
             * que otras posibles series anteriores, en cuyo caso, actualizaremos la variable maxConsecutiva
             * que es la que cuenta la serie de ocurrencias más larga que tenga lugar.
             */
            if (contador > 0) {//Estabamos contando..
               if (contador > maxConsecutiva) {//Actualizamos maxConsecutiva
                  maxConsecutiva = contador;
               }
               contador = 0; //Reiniciamos contador, pues esta serie de ocurrencias ya ha finalizado
            }      
         }
      
      return maxConsecutiva;
   }
   

   public static void main(String[] args) {
      
      Integer[] numeros = {8, 10, 20, 30, 8, 8, 8, 4, 10, 10, 5, 10, 30, 6, 10, 10, 10, 20, 8, 8, 8, 8, 8, 8};
      
      System.out.println(maxNumRepeated(numeros, 10));

   }

}

Con esta solución, APARENTEMENTE ya está solucionado lo que nos piden.
Y remarco lo de aparente porque en realidad hay un pequeño fallo en la lógica que puede pasar desapercibido.
Si lo ejecutas con el array que he puesto de ejemplo y preguntas cual es la mayor serie de repeticiones del número 10, te saldrá en pantalla un 3
Eso es correcto.
Si preguntas por el 20, te saldrá un 1
También es correcto.

Pero, si preguntas por el número 8, te saldrá en pantalla un 3
¡Eso es incorrecto!
Lo correcto sería que respondiera con un 6, ya que la mayor serie de repeticiones del número 8 son claramente los últimos seis elementos del array.
Me gustaría que lo probaras para que vieras que efectivamente algo falla.

Pero, ¿que está fallando? ¿Por qué sí lo hace bien con otros números y no con el 8?

El problema tiene su respuesta.
Si miramos el código, usamos la variable maxConsecutiva para controlar cuál es la mayor serie de repeticiones consecutivas de un número concreto.

Esta variable la actualizamos cuando, tras estar contando una serie de ocurrencias/repeticiones, nos encontramos con un elemento distinto, lo que significa que la serie de ocurrencias ha finalizado y tenemos que comprobar si esta serie ha sido mayor que otras.
Y aquí esta el problema SOLO actualizamos maxConsecutiva cuando encontramos un elemento distinto.

Si preguntamos por el elemento 10, las series de ocurrencias(marcadas en verde) finalizan al encontrar un elemento distinto (marcado en rojo)

Integer[] numeros = {8, 10, 20, 30, 8, 8, 8, 4, 10, 10, 5, 10, 30, 6, 10, 10, 10, 20, 8, 8, 8, 8, 8, 8};

Cada vez que nos encontramos en uno de esos elementos en rojo, se actualiza maxConsecutiva. Y aparentemente esto funciona bien.

Ahora vamos a fijarnos las series con el número 8:

Integer[] numeros = {8, 10, 20, 30, 8, 8, 8, 4, 10, 10, 5, 10, 30, 6, 10, 10, 10, 20, 8, 8, 8, 8, 8, 8};

Aquí se aprecia cuál es el problema. La última serie de ocurrencias, la de los seis 8, como está al final del array, no tenemos un "elemento rojo" tras esta serie. Por lo tanto, no estamos actualizando la variable maxConsecutiva para esta última serie de ocurrencias y por ello el código que hemos escrito no es del todo correcto, pues falla cuando una serie de ocurrencias esta justo al final del array.

Pero por suerte, esto es fácil de solucionar.
Si quieres intentar encontrarle tú la solución adelante, estos problemas "tontos" y casi impensables, intentar solucionarlos enseñan mucho sobre cómo "piensan" los ordenadores.

En cualquier caso, aquí abajo publico de nuevo el ejercicio, marcando en verde la modificación necesaria para esquivar este problemita.
Pregunta lo que creas oportuno.
Y sobre la segunda parte del ejercicio, si me entero de algo que pueda ser útil, lo compartiré por aquí.
Un saludo.

public final class Test {
   
   public static int maxNumRepeated(Integer[] a, Integer elem) {
      int contador = 0;
      int maxConsecutiva = 0;
      
      for (int i=0; i<a.length; i++)
         if (a[ i ].equals(elem)) {//Ocurrencia, contamos
            contador++;
            /*
             * Existe la posibilidad de que una serie de ocurrencias finalice por el hecho
             * de que ya hemos llegado al ultimo elemento del array. En este caso, hemos de
             * comprobar si esta serie es mayor que otras que hayan podido haber anteriormente
             */
            if (i == a.length-1) {
               if (contador > maxConsecutiva) {//Actualizamos maxConsecutiva
                  maxConsecutiva = contador;
               }
            }
         }
         else {//No hay ocurrencia. Aquí tenemos dos posibles escenarios.
            
            /*
             * Escenario (1). NO estabamos contando porque en este momento no habían ocurrencias.
             * Podemos saber que estamos en este escenario si contador == 0.
             * En cualquier caso, en este escenario no tenemos que hacer nada de nada, así que ni
             * siquiera vamos a preguntar por el valor de contador. Simplemente dejamos que el bucle
             * siga su curso.
             */
            
            /*
             * Escenario (2). SÍ estabamos contando porque estabamos dentro de una serie de ocurrencias.
             * Podemos saber que estamos en este escenario si contador > 0.
             * En este escenario, tenemos que averiguar si esta serie de ocurrencias consecutivas (que ya ha
             * terminado puesto que ahora ya han dejado de haber ocurrencias), hay que ver si es mayor
             * que otras posibles series anteriores, en cuyo caso, actualizaremos la variable maxConsecutiva
             * que es la que cuenta la serie de ocurrencias más larga que tenga lugar.
             */
            if (contador > 0) {//Estabamos contando..
               if (contador > maxConsecutiva) {//Actualizamos maxConsecutiva
                  maxConsecutiva = contador;
               }
               contador = 0; //Reiniciamos contador, pues esta serie de ocurrencias ya ha finalizado
            }      
         }
      
      return maxConsecutiva;
   }
   

   public static void main(String[] args) {
      
      Integer[] numeros = {8, 10, 20, 30, 8, 8, 8, 4, 10, 10, 5, 10, 30, 6, 10, 10, 10, 20, 8, 8, 8, 8, 8, 8};
      
      System.out.println(maxNumRepeated(numeros, 8 ));

   }

}

[Mario R. Rancel]

Buenas tardes, procedo a cambiar el tema al foro "C, C++, C#, Java, Visual Basic, HTML, PHP, CSS, Javascript, Ajax, Joomla, MySql y más". A alfredoDSK recomedarle que lea el hilo de normas, sugerencias y políticas en https://aprenderaprogramar.com/foros/index.php?topic=1460.0

Saludos