Java - Ayuda ejercicio Java

 
Vista:
sin imagen de perfil
Val: 7
Ha aumentado su posición en 5 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda ejercicio Java

Publicado por Jesus (4 intervenciones) el 06/11/2018 17:27:18
Hola, estoy haciendo unos ejercicios para estudiar y este no me sale, y me gustaria saber hacerlo ya que salen cosas las cuales me interesan para estudiar. Si alguien lo sabe hacer o me pueda echar una mano me ayudaria mucho, grácias!

EJERCICIO:
Imagina un sistema que comprime archivos en un 80% y los guarda en un medio de
almacenamiento. Antes que el archivo comprimido se guarde, se debe dividir en bloques de
512 bytes cada uno. Hacer un programa para este sistema, que primero lea el número de
bloques disponibles en el medio de almacenamiento. Luego en un bucle, leer el tamaño de
los archivos sin comprimir y determinar si el archivo al comprimirse puede guardarse en el
espacio restante del medio de almacenamiento. En caso de sea posible guardarlo, el
programa comprime el archivo y lo guarda en el medio de almacenamiento. Se continua
hasta que se encuentre un archivo que exceda el espacio disponible del medio.
Por ejemplo, supongamos que un medio puede almacenar 1000 bloques. Un archivo de 1100
bytes se comprime a un tamaño de 880 bytes y requiere 2 bloques. El espacio disponible
ahora es 998 bloques. Un archivo de 20000 bytes se comprime a 16000 bytes y requiere 32
bloques. El espacio disponible ahora es 966 bloques
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 ejercicio Java

Publicado por Kabuto (1378 intervenciones) el 07/11/2018 00:06:20
Hola.
Este ejercicio tiene más "complejidad" matemática, que no algorítmica.
A ver, necesitamos una variable que represente el disco duro y que su valor sea la cantidad de bloques disponibles.
Vamos a poner 1000 bloques, como indica el ejemplo:

1
static int disco = 1000; //1000 bloques de 512 bytes

Bien, la mecánica será que nos den por teclado tamaños de archivos en bytes. Luego simulamos que lo comprimimos al 80% y el valor obtenido, calculamos cuantos bloques de 512 va a necesitar.
Para hacer todo esto podemos usar un método que se encargue de calcular los bloques necesarios para un archivo recibido como argumento.
1
static int calculaBloques(int archivo)
Lo primero que hará será comprimir al 80%, o lo que es lo mismo, calcular el 20% del total del archivo y restarselo.
1
int comprimido = archivo - (archivo*20/100);//Comprimimos al 80%

Ahora hay que calcular cuantos bloques de 512 necesita ocupar, para esto basta con dividir entre 512.
1
int bloques = comprimido / 512; //Calculamos bloques de 512bytes necesita
Si por ejemplo el comprimido mide 1024:
1024 / 512 = 2
Ergo, necesita 2 bloques.

Pero hay un problemita. Nuestra division aquí en el programa nos da un resultado entero, no decimal.
Es decir, ¿que pasa si el comprimido ocupa 1025 bytes?
Este es el resultado real: 1025 / 512 = 2,001953125
Así que un comprimido de 1025 bytes, no cabe en solo 2 bloques, en realidad va a ocupar 3 bloques. Del tercero solo ocupara un byte, pero aún así quedará asignado a él, el resto de bytes se desperdician, pero bueno, esto no nos atañe.

El problema es que nuestra division 1025 / 512 en el programa nos va a devolver un 2, porque solo nos da la parte entera del resultado. No nos va decir nada de la parte decimal. Así que esto no funcionará bien, porque en realidad tendría que ocupar 3 bloques.
¿Cómo podemos solucionar esto?"
Fácil, lo que hacemos es que después de hacer la división, preguntamos por el resto de la división con el operador "módulo" --> %
Si este operador nos devuelve cualquier valor mayor que 0, es que en realidad la division no ha dado un resultado entero. Esto implica lo que decíamos antes, que el archivo va a ocupar un espacio más de lo que nos ha indicado la división, así que nos basta con incrementar el resultado obtenido antes.

1
2
3
int bloques = comprimido / 512; //Calculamos bloques de 512bytes necesita
if (comprimido % 512 > 0) //Si el resto no es 0, es que el archivo aun va a ocupar parte de otro bloque más.
	bloques++;

Y ya tenemos correctamente calculados los bloques necesarios, este sería el método final:
1
2
3
4
5
6
7
8
9
10
static int calculaBloques(int archivo) {
 
	int comprimido = archivo - (archivo*20/100);//Comprimimos al 80%
 
	int bloques = comprimido / 512; //Calculamos bloques de 512bytes necesita
	if (comprimido % 512 > 0) //Si el resto no es 0, es que el archivo aun va a ocupar parte de otro bloque más.
		bloques++;
 
	return bloques;
	}


Vale, ahora ya sabemos calcular los bloques que va a necesitar un fichero al comprimirlo.

La dinámica del programa sería:
- Pedir tamaño archivo al usuario
- Calcular los bloques que necesita (ya tenemos método para esto)
- Comprobar si en nuestro "disco" quedan bloques suficientes libres.
- Si hay suficientes, restamos los bloques calculados a los bloques del disco y volvemos a pedir otro archivo al usuario
- Si NO hay suficientes, avisamos de que no queda espacio libre y se termina el programa.

Y ya está, es muy fácil. Como digo, tiene más miga matemática, que no algorítmica.

Te dejo aquí mi ejercicio completo. Aunque por supuesto, recomiendo que intentes solucionarlo ahora que conoces los pasos a seguir.
Un saludo.

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
package simulaComprime;
 
import java.util.Scanner;
 
public final class Compresor {
 
	static int disco = 1000;//1000 bloques de 512 bytes
 
        //Metodo para calcular bloques necesarios para un archivo
	static int calculaBloques(int archivo) {
 
		int comprimido = archivo - (archivo*20/100);//Comprimimos al 80%
 
		int bloques = comprimido / 512; //Calculamos bloques de 512bytes necesita
		if (comprimido % 512 > 0) //Si el resto no es 0, es que el archivo aun va a ocupar parte de otro bloque más.
			bloques++;
 
		return bloques;
	}
 
	public static void main(String[] args) {
 
		Scanner teclado = new Scanner(System.in);
		int archivo = 0;
		boolean espacioSuficiente = true; //Cuando no haya espacio, la pondremos a FALSE y así terminará el bucle
 
		do {
			System.out.println("Bloques libres en disco: " + disco);
			System.out.print("Indique tamaño archivo: ");
			archivo = teclado.nextInt();
			int bloques = calculaBloques(archivo);
			System.out.println("Bloques necesarios para guardar el archivo comprimido: " + bloques);
			if (bloques <= disco) { //SI hay espacio suficiente
				disco -= bloques;
				System.out.println("Archivo almacenado\n\n");
			}
			else { //No hay espacio suficiente, FIN de programa.
				espacioSuficiente = false;
				System.out.println("No hay suficientes bloques");
			}
		}while(espacioSuficiente);
		teclado.close();
	}
 
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar
sin imagen de perfil
Val: 7
Ha aumentado su posición en 5 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda ejercicio Java

Publicado por Jesus (4 intervenciones) el 07/11/2018 17:22:20
Muchas gracias Kabuto, me a sido de gran ayuda que ademas me lo expliques todo. Gracias!
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