Java - solicito ayuda

 
Vista:
sin imagen de perfil

solicito ayuda

Publicado por jamie (4 intervenciones) el 08/12/2023 19:31:23
como seria el desarrollo de estos 4 ejercicios java

1.Se necesita desarrollar un programa para gestionar las facturas en una empresa que se dedica a la venta de desinfectantes industriales.  En cada factura figura: el código del artículo (001,002,003), la cantidad vendida en litros y el precio por litro. De las 3 facturas introducidas, se necesita que el programa solicite al usuario que ingrese el número del artículo, la cantidad vendida en litros y el precio por litro, luego el programa debe calcular y mostrar por pantalla al usuario la Facturación total, cantidad en litros vendidos de cada artículo y cuantas facturas se emitieron de más de 1000 lempiras.

2.Crea un programa que reciba como parámetro una cadena de texto con una frase y que devolver dicha cadena, pero invirtiendo la primera y la última palabra.Ejemplo: el cielo está soleado, el resultado sería: soleado cielo está el

3.Se cuenta con la siguiente información:
Las edades de 15 estudiantes del turno mañana.
Las edades de 20 estudiantes del turno tarde.
Las edades de 30 estudiantes del turno noche.
Las edades de cada estudiante deben ser números aleatorios.
Obtener el promedio de las edades de cada turno (tres promedios)
Imprimir dichos promedios (promedio de cada turno)
Mostrar por pantalla un mensaje que indique cuál de los tres turnos tiene un promedio de edades mayor.

4.Algoritmo que dado un valor N entero positivo, calcule e imprima los elementos correspondientes a la conjetura de Ullman que consiste en lo siguiente:
Empiece con cualquier entero positivo.
Si es par, divídalo entre 2, si es impar multiplíquelo por 3 y agréguele 1.
Obtenga enteros sucesivamente repitiendo el proceso.
Al final obtendrá el número 1, independientemente del entero inicial. Por ejemplo, cuando el entero inicial es 26, la secuencia será:
26 13 40 20 10 5 16 8 4 2 1
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

solicito ayuda

Publicado por Kabuto (1383 intervenciones) el 09/12/2023 13:14:12
Para el primer ejercicio se ha de considerar que solo existen tres artículos, con los códigos 001, 002, y 003 (que es lo mismo que 1, 2 y 3)

Pues se piden datos para tres facturas, para cada una, se pide el código de artículo, litros vendidos y precio del litro.

Para saber cuantos litros se ha vendido de cada artículo se necesita declarar tres variables, una por cada artículo, donde sumar esos litros vendidos. O si no usar un arreglo de tres elementos.

Lo mismo para guardar el total de cada factura. O se declaran tres variables, o se utiliza un arreglo de tres elementos.

La ventaja de usar los arreglos, es que se reducen las líneas de código necesarias ya que se facilita escribir el proceso necesario una sola vez y repetirlo con un bucle.
En cambio si usamos variables individuales, el bucle no es de tanta ayuda y casi nos obliga a repetir el mismo proceso tres veces, usando en cada uno las variables individuales que corresponda.


Dejo una solución usando arreglos. No se si ya los conoces y/o se espera que los uses en estos ejercicios.
Si no es así, intenta de todos modos comprender la lógica que se ha seguido y hacer tú una versión sin usar arreglos.
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
import java.util.Scanner;
 
public class FacturaDesinfectantes {
 
	public static void main(String[] args) {
 
		Scanner teclado = new Scanner(System.in);
		double[] valoresFacturas = new double[3];
		int[] litrosArticulos = new int[3]; //Solo hay 3 articulos
 
		for (int factura = 0; factura < 3; factura++) {
			System.out.println("\n-> Factura #" + (factura+1));
			//Pedimos datos de esta factura
			System.out.print("Codigo articulo: ");
			int codigo = teclado.nextInt();
			System.out.print("Litros vendidos: ");
			int litros = teclado.nextInt();
			System.out.print("Precio del litro: ");
			double precio = teclado.nextDouble();
			//Comprobamos si codigo articulo es correcto
			if (codigo >= 1 && codigo <=3) {
				//Acumulamos litros en la posicion del arreglo correspondiente
				litrosArticulos[codigo - 1] += litros;
				//Guardamos valor factura en la posicion del arreglo correspondiente
				valoresFacturas[factura] = litros * precio;
			}
			else {
				System.out.println("Articulo desconocido. Esta factura no se computa");
				factura--;//Retrasamos el ciclo del bucle porque esta factura no es computable
			}
		}
 
		//Terminado el bucle, ya tenemos las tres facturas computadas.
 
		//Recorremos el arreglo de facturas para acumular su suma y contar cuantas sobrepasan las 1000 lempiras
		int contador = 0;
		double totalFacturas = 0;
		for (double valor: valoresFacturas) {
			totalFacturas += valor;
			if (valor > 1000)
				contador++;
		}
		// Mostramos resultados
		System.out.println("\nFacturacion total: " + totalFacturas);
		System.out.println("Facturas con valor superior a 1000: " + contador);
		System.out.println("Litros vendidos del articulo 001: " + litrosArticulos[0]);
		System.out.println("Litros vendidos del articulo 002: " + litrosArticulos[1]);
		System.out.println("Litros vendidos del articulo 003: " + litrosArticulos[2]);
 
		teclado.close();
		System.out.println("\n\n\t\tFIN DE PROGRAMA");
	}
 
}



Para el segundo ejercicio, podemos dividir la cadena en tres partes: primera palabra, ultima palabra y el cuerpo(el resto de la cadena)

Para saber donde termina la primera palabra, buscamos la posición del primer espacio en blanco en la cadena. Para esto podemos usar el método indexOf()
Y con el método lastIndexOf() podemos encontrar el último espacio en blanco de la cadena y así saber donde comienza la última palabra.

Teniendo esas dos posiciones, podemos usar el método subString() para obtener las tres partes de la cadena en distintas variables y ya luego intercambiar esas partes como queramos.
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
public class IntercambiaPalabras {
 
	public static void main(String[] args) {
		Scanner teclado = new Scanner(System.in);
 
		System.out.print("Introduzca frase: ");
		String frase = teclado.nextLine();
 
		//Buscamos primer espacio en blanco para ver donde TERMINA la primera palabra
		int primerEspacio = frase.indexOf(" ");
		//Y el último espacio, para ver donde COMIENZA la última palabra
		int ultimoEspacio = frase.lastIndexOf(" ");
 
		//Extraemos primera palabra
		String primera = frase.substring(0, primerEspacio);
		//Extraemos última palabra
		String ultima = frase.substring(ultimoEspacio + 1);
		//Extraemos el "cuerpo" de la frase, sin la primera y última palabra
		String cuerpo = frase.substring(primerEspacio, ultimoEspacio + 1);
 
		//Tenemos las tres partes, mostramos en pantalla intercambiando primera y última palabra
		System.out.print("Frase intercambiada: ");
		System.out.println(ultima + cuerpo + primera);
 
		teclado.close();
		System.out.println("\n\n\t\tFIN DE PROGRAMA");
	}
 
}

Existe otra forma un poco más sencilla. Y es usando el método split() para dividir la cadena en partes separadas según donde exista un espacio en blanco.
Esto nos dará un arreglo con todas las palabras de la frase. Ya solo habría que intercambiar la primera posición del arreglo con la última y después mostrarlas todas en pantalla.

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
public class IntercambiaPalabras2 {
 
	public static void main(String[] args) {
		Scanner teclado = new Scanner(System.in);
 
		System.out.print("Introduzca frase: ");
		String frase = teclado.nextLine();
 
		//Obtenemos un arreglo con la cadena troceada allá donde exista un espacio en blanco
		String[] partes = frase.split(" ");
 
		//Intercambiamos primera y última parte
		String aux = partes[0];
		partes[0] = partes[partes.length-1];
		partes[partes.length-1] = aux;
 
		//Recorremos el arreglo mostrando todas las partes
		System.out.print("Frase intercambiada: ");
		for (String palabra: partes)
			System.out.print(palabra + " ");
 
		teclado.close();
		System.out.println("\n\n\t\tFIN 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
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

solicito ayuda

Publicado por Kabuto (1383 intervenciones) el 09/12/2023 13:39:35
El tercer ejercicio es sencillo.

Generar al azar las edades de un turno de estudiantes, sumar esas edades y calcular el promedio.
No nos dan unos límites de edades, así que los decidimos nosotros mismos.

Esto lo hacemos para tres turnos distintos.

Cuando tengamos los tres promedios, comprobamos cuál es el mayor.

Dejo el ejercicio comenzado, intenta completarlo tú:
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
import java.util.Random;
 
public class PromediosEdades {
 
	public static void main(String[] args) {
		Random azar = new Random();
		//Variables para acumular las edades de cada turno
		int turnoMa = 0, turnoTa = 0, turnoNo = 0;
		//Y para los promedios
		double promedioMa = 0, promedioTa = 0, promedioNo = 0;
 
		//Generamos edades para cada turno, acumulamos edades y calculamos promedio.
		//Aplicamos un rango de edad entre 16 y 55 años
 
		//turno mañana(15 estudiantes)
		for (int i = 0; i < 15; i++)
			turnoMa += azar.nextInt(16, 56);
		//Promedio
		promedioMa = turnoMa / 15;
		System.out.println("Edad promedio del turno de mañana: " + promedioMa);
 
		//turno tarde(20 estudiantes)
 
 
 
		//turno noche(30 estudianes
 
 
 
		//Indicar cuál turno tiene mayor promedio
 
		System.out.println("\n\n\t\tFIN DE PROGRAMA");
	}
 
}


El cuarto ejercicio tampoco tiene dificultado.
Pedimos número y, dentro de un bucle while, iremos modificando ese número hasta que alcance el valor 1, momento en el que terminará el bucle.

Las modificaciones consistirán en dividirlo entre 2 cuando sea para o multiplicarlo por 3 y sumarle 1, cuando sea impar.
Tras cada modificación mostramos el nuevo número en pantalla para crear una secuencia.


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
public class SecuenciaUllman {
 
	public static void main(String[] args) {
 
		Scanner teclado = new Scanner(System.in);
 
		System.out.print("Introduzca numero positivo: ");
		int numero = teclado.nextInt();
 
		System.out.println("Secuencia Ullman: ");
		System.out.print(numero + " ");
 
		while (numero > 1) {
			//Si es par, se divide entre 2
			if (numero % 2 == 0)
				numero /= 2;
			else { //Impar, se multiplica x 3 y se le suma 1
				numero *= 3;
				numero++;
			}
			System.out.print(numero + " ");
		}
 
		teclado.close();
		System.out.println("\n\n\t\tFIN 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