Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » AYUDA!!! usando arreglos (verdadero reto)

Java - AYUDA!!! usando arreglos (verdadero reto)

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil

AYUDA!!! usando arreglos (verdadero reto)

Publicado por Pedro Marquez (1 intervención) el 01/11/2021 07:29:45
Hola, es un programa en el que el usuario ingresa un numero, que es el numero de fracciones que va a dar, a continuación el usuario escribe el denominador y denominador del numero de fracciones que escogió. Al final como salida, debe de salir el numero de veces que esta repetida la misma fracción, osea que el numerador y denominador son iguales.
A continuación;
import java.util.Scanner;
class calificaciones
{
int num, den;
calificaciones(int num, int den)
{
this.num = num;
this.den = den;
}
calificaciones()
{

}
public static void main(String[] args)
{
int h;
Scanner sc;
sc = new Scanner(System.in);
h = sc.nextInt();
double[]contador=new double[h];
for (int calificaciones=0; calificaciones<h; calificaciones++)
{
int c, d;
Scanner cs;
cs = new Scanner(System.in);
int a = c= sc.nextInt();
int b = d= sc.nextInt();
// double[]contador=new double[h];
double[]calificaciones = new (a,b)calificaciones;


for(double i=0; i<calificaciones.length; i++)
{
contador[calificaciones[i]]+=1;
}
for(double j=0; j<contador.length;j++)
{
System.out.println(j+" se repite "+contador[j]+" ");
}
}
}
public String toString()
{
return this.num + "/" +this.den;
}

}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

AYUDA!!! usando arreglos (verdadero reto)

Publicado por Kabuto (1385 intervenciones) el 01/11/2021 11:49:02
A ver, propongo crear una clase Fraccion sencilla, pero que sepa por ella misma cómo ha de compararse con otras fracciones para determinar si son iguales.
Para ello sobreescribiremos el método equals()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Fraccion {
 
	private int num;
	private int den;
 
	public Fraccion(int numerador, int denominador) {
		num = numerador;
		den = denominador;
	}
 
	@Override
	public boolean equals(Object obj) {
		if (obj instanceof Fraccion) {
			Fraccion otraFcn = (Fraccion) obj;
			//Se consideran iguales si coinciden numeradores y denominadores
			if (num == otraFcn.num && den == otraFcn.den)
				return true;
			else
				return false;
		}
		else
			return false;
	}
 
	@Override
	public String toString() {
		return String.format("[%2d/%2d]", num, den);
	}
 
}


Con esto, en un main() podemos crear un array de fracciones con los valores que proponga el usuario.
Con dos bucles anidados, seleccionamos cada una de las fracciones creadas y a partir de ella, recorremos el resto de posiciones del array comparando si coincide con alguna de las otras fracciones.
Si coincide, aumentamos un contador. Podemos ir creando sobre la marcha un String que muestre la fracción que se repite y cuantas veces lo hace.
Así cada vez que encontremos una fracción que se repite, contamos sus repeticiones, pasamos los datos al String y continuamos comprobando las demás.

Luego al final mostramos las fracciones creadas y el resultado acumulado en el String que hemos ido construyendo.

Este código cumple esto, sin embargo, tiene un defecto que luego explico:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
import java.util.Scanner;
 
public class BuscaFracciones {
 
	public static void main(String[] args) {
		Scanner teclado = new Scanner(System.in);
 
		//Creamos array de fracciones
		System.out.print("¿Cuántas fracciones quiere crear?: ");
		Fraccion[] fracciones = new Fraccion[teclado.nextInt()];
		//Las fracciones se crearán con valores al azar
		for (int c = 0;  c < fracciones.length; c++) {
			System.out.println("\nvalores para crear una fraccion.");
			System.out.print("Numerador: ");
			int num = teclado.nextInt();
			System.out.print("Denominador: ");
			int den = teclado.nextInt();
 
			fracciones[c] = new Fraccion(num, den);
		}
 
		//Buscamos fracciones repetidas.
		//Podemos ir construyendo un String con las fracciones repetidas
		StringBuilder repetidas = new StringBuilder();
		//Con un for recorremos cada fraccion.
		for (int posActual = 0; posActual < fracciones.length; posActual++) {
			Fraccion actual = fracciones[posActual];
			int repite = 0;
			//Con otro for, recorremos demas posiciones a partir de la actual
			for (int posRestantes = posActual + 1; posRestantes < fracciones.length; posRestantes++)
				if (actual.equals(fracciones[posRestantes]))
					repite++;
			//Si han habido repeticiones, pasamos datos al String
			if (repite > 0)
				repetidas.append(actual + "  -> Veces repite: " + repite + "\n");
		}
 
		//Mostramos resultados
		System.out.println("\n\tFRACCIONES CREADAS");
		int mostrados = 0;
		for (Fraccion frc: fracciones) {
			mostrados++;
			if (mostrados % 5 == 0) //Cada 5 fracciones mostradas hacemos un salto de línea
				System.out.println(frc);
			else
				System.out.print(frc + " ");
		}
 
		System.out.println("\n\tREPETICIONES ENCONTRADAS");
		System.out.println(repetidas.toString());
 
		System.out.println("\n\t\tFIN DE PROGRAMA");
		teclado.close();
	}
 
}

El defecto que tiene es que no es capaz de "recordar" cuándo una fracción ya ha sido detectada como repetida.
Entonces, si una fracción se repite varias veces, por cada repetición añadirá al String de resultados una línea como si fuera una "repetición nueva"

Miren este resultado en pantalla, la fracción 12/10 aparece varias veces como una "repetición encontrada", cuando lo correcto sería que solo aparezca una sola vez:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
¿Cuántas fracciones quiere crear?: 10
 
valores para crear una fraccion.
Numerador: 12
Denominador: 10
 
valores para crear una fraccion.
Numerador: 23
Denominador: 12
 
valores para crear una fraccion.
Numerador: 7
Denominador: 8
 
valores para crear una fraccion.
Numerador: 12
Denominador: 10
 
valores para crear una fraccion.
Numerador: 23
Denominador: 12
 
valores para crear una fraccion.
Numerador: 6
Denominador: 6
 
valores para crear una fraccion.
Numerador: 9
Denominador: 3
 
valores para crear una fraccion.
Numerador: 12
Denominador: 10
 
valores para crear una fraccion.
Numerador: 12
Denominador: 10
 
valores para crear una fraccion.
Numerador: 12
Denominador: 10
 
	FRACCIONES CREADAS
[12/10] [23/12] [ 7/ 8] [12/10] [23/12]
[ 6/ 6] [ 9/ 3] [12/10] [12/10] [12/10]
 
	REPETICIONES ENCONTRADAS
[12/10]  -> Veces repite: 4
[23/12]  -> Veces repite: 1
[12/10]  -> Veces repite: 3
[12/10]  -> Veces repite: 2
[12/10]  -> Veces repite: 1
 
 
		FIN DE PROGRAMA

Tenemos que hallar una manera de comprobar si una fracción ya ha sido detectada como "repetida", para que en sus próximas repeticiones no la volvamos a incluir en el String de resultados.
Hay varias soluciones, como crear un array paralelo con las fracciones repetidas, o marcar como null en el array las fracciones repetidas para no volver a evaluarlas mientras los bucles hacen sus recorridos.

Pero lo más sencillo, aprovechando que estamos trabajando con un String para grabar los resultados, es comprobar si dicho String ya contiene ( contains() ) una fracción antes de añadirla.
Para ello, solo hay que añadir una condición extra al IF donde decidimos si añadimos una fracción al String
1
2
3
4
5
6
7
8
9
10
11
12
13
StringBuilder repetidas = new StringBuilder();
		//Con un for recorremos cada fraccion.
		for (int posActual = 0; posActual < fracciones.length; posActual++) {
			Fraccion actual = fracciones[posActual];
			int repite = 0;
			//Con otro for, recorremos demas posiciones a partir de la actual
			for (int posRestantes = posActual + 1; posRestantes < fracciones.length; posRestantes++)
				if (actual.equals(fracciones[posRestantes]))
					repite++;
			//Si han habido repeticiones, pasamos datos al String, excepto si ya existe en este
			if (repite > 0 && !repetidas.toString().contains(actual.toString()))
				repetidas.append(actual + "  -> Veces repite: " + repite + "\n");
		}


De esta manera, ahora aunque una fracción se repita varias veces, en el String de repeticiones solo aparecerá una vez:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
¿Cuántas fracciones quiere crear?: 10
 
valores para crear una fraccion.
Numerador: 12
Denominador: 10
 
valores para crear una fraccion.
Numerador: 4
Denominador: 5
 
valores para crear una fraccion.
Numerador: 12
Denominador: 10
 
valores para crear una fraccion.
Numerador: 6
Denominador: 7
 
valores para crear una fraccion.
Numerador: 12
Denominador: 10
 
valores para crear una fraccion.
Numerador: 4
Denominador: 5
 
valores para crear una fraccion.
Numerador: 12
Denominador: 10
 
valores para crear una fraccion.
Numerador: 9
Denominador: 8
 
valores para crear una fraccion.
Numerador: 12
Denominador: 10
 
valores para crear una fraccion.
Numerador: 6
Denominador: 7
 
	FRACCIONES CREADAS
[12/10] [ 4/ 5] [12/10] [ 6/ 7] [12/10]
[ 4/ 5] [12/10] [ 9/ 8] [12/10] [ 6/ 7]
 
	REPETICIONES ENCONTRADAS
[12/10]  -> Veces repite: 4
[ 4/ 5]  -> Veces repite: 1
[ 6/ 7]  -> Veces repite: 1
 
 
		FIN DE PROGRAMA
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar