Java - Ayuda con problema de pizzas

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

Ayuda con problema de pizzas

Publicado por Marthy (11 intervenciones) el 19/09/2018 20:29:54
Este año estoy llevando el curso de algoritmos y estructura de datos. Si me pudieran ayudar en este problema que vino en mi examen.El enunciado del problema está en la foto. Gracias.
EL CODIGO ESTA INCOMPLETO(ME SALE ERROR EN EL ARREGLO) PERO LA MAYORIA ESTA AHI, POR FAVOR SI PUDIERAN COMPLETARLO O DARLE UNA MEJOR FORMA. GRACIAS. (aun estamos a lo mucho en clases, metodos, parametros, sin complejidad superior porfavor)

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
package examen_pizzas;
 
import java.util.Scanner;
 
public class Examen_Pizzas {
static Scanner sc=new Scanner(System.in);
 
static int[] tamaño=new int[3];
static int cliente,tipo,ingrediente,menu,peque,medi,gran;
static float preparacion;
static float valor_pulgada;
static float valor_ingrediente;
static float area;
static float pizza;
static float ganancia_dia,costo_total,precio_de_venta,venta_dia,costo_dia,pizza_pequeña,pizza_mediana,pizza_grande;
static float pizza_total;
    public static void main(String[] args) {
       cliente();
       datos();
       tamaño();
       menu();
    }
  public static void cliente(){
        System.out.println("Ingrese el numero de clientes que han comido en la pizzeria: ");
        cliente=sc.nextInt();
        System.out.println("¿Cuantos clientes comieron pizza en tamaño pequeño?");
        peque=sc.nextInt();
        System.out.println("¿Cuantos clientes comieron pizza en tamaño mediano?");
        medi=sc.nextInt();
        System.out.println("¿Cuantos clientes comieron pizza en tamaño grande?");
        gran=sc.nextInt();
        }
public static void datos(){
    System.out.print("Ingrese el costo fijo de preparacion: ");
    preparacion=sc.nextFloat();
    System.out.print("Ingrese el valor por pulgada cuadrada de la pizza: ");
    valor_pulgada=sc.nextFloat();
    System.out.print("Ingrese el costo fijo de un ingrediente: ");
    valor_ingrediente=sc.nextInt();
}
public static void tamaño(){
    System.out.print("Ingrese el tamaño de la pizza(1. Pequeña  2. mediana  3.Grande):  ");
    tamaño[3]=sc.nextInt();
    System.out.print("Digite el tipo de pizza(1. Sencilla  2.Con Ingredientes extra): ");
    tipo=sc.nextInt();
    if(tipo==2){
        System.out.println("Ingrese el numero de ingredientes extra: ");
        ingrediente=sc.nextInt();
    }else{
    ingrediente=0;
    }
    switch (tamaño[3]) {
        case 1:
            area=(float)78.539;
            break;
        case 2:
            area=(float)113.897;
            break;
        case 3:
            area=(float)201.061;
            break;
        default:
            break;
    }
    pizza=(area*valor_pulgada)+(ingrediente*valor_ingrediente)+preparacion;
    System.out.println("El precio de la pizza es: "+pizza);
 
}
public static void menu(){
    System.out.println("\tMENU");
    System.out.println("1. Mostrar la ganancia del dia, la venta del dia y el costo del dia");
    System.out.println("2. Mostrar la ganancia del dia por tamaño de pizza");
    System.out.println("3. Mostrar el numero de pizzas totales vendidas y el numero de pizzas vendidas por tamaño");
    System.out.println("4. Mostrar la ganancia del dia, la venta y el costo del dia por tamaño de pizza");
    System.out.println("5. Imprimir la matriz en donde se almacenaron las ventas(en formato matriz)");
    System.out.println("6. Sslir");
    System.out.println("\nIngrese un numero para el menu: ");
    menu=sc.nextInt();
 
    if(menu==1){
        costo_total=preparacion+valor_ingrediente+valor_pulgada;
    precio_venta=1.5*costo_total;
        ganancia_dia=costo_total-precio_de_venta;
        venta_dia=cliente*pizza;
        costo_dia=cliente*costo_total;
        System.out.println("La ganancia del dia es: "+ganancia_dia);
        System.out.println("La venta del dia es: "+venta_dia);
        System.out.println("El costo del dia es: "+costo_dia);
    }
    if(menu==2){
        if(tamaño[3]==1){
         area=(float)78.539;
            System.out.println("Ingrese el numero de pizzas pequeñas,vendidas en el dia: ");
            pizza_pequeña=sc.nextInt();
            pizza=pizza_pequeña*((area*valor_pulgada)+(ingrediente*valor_ingrediente)+preparacion);
            System.out.println("La ganancia por dia de la pizza pequeña es: "+pizza);
        }
        if(tamaño[3]==2){
        area=(float)113.897;
          System.out.println("Ingrese el numero de pizzas medianas,vendidas en el dia: ");
            pizza_mediana=sc.nextInt();
            pizza=pizza_mediana*((area*valor_pulgada)+(ingrediente*valor_ingrediente)+preparacion);
            System.out.println("\nLa ganancia por dia de la pizza pequeña es: "+pizza);
        }
    if(tamaño[3]==3){
    area=(float)201.061;
     System.out.println("Ingrese el numero de pizzas grandes,vendidas en el dia: ");
            pizza_grande=sc.nextInt();
            pizza_grande=pizza_grande*((area*valor_pulgada)+(ingrediente*valor_ingrediente)+preparacion);
            System.out.println("\nLa ganancia por dia de la pizza pequeña es: "+pizza_grande);
            }
    }
    if(menu==3){
    pizza_total=pizza_pequeña+pizza_mediana+pizza_grande;
        System.out.println("El numero totales de pizzas vendidas es: "+pizza_total);
        System.out.println("\nEl numero de pizzas pequeñas es: "+pizza_pequeña);
        System.out.println("\nEl numero de pizzas medianas es: "+pizza_mediana);
        System.out.println("\nEl numero de pizzas grandes es: "+pizza_grande);
    }
    if(menu==4){
 
 
    }
}
}
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 con problema de pizzas

Publicado por Kabuto (979 intervenciones) el 21/09/2018 00:56:59
Hola.

1-º no se ve la imagen con la enunciado.

2-º Como recomendación general, evita usar la letra ñ al poner nombre a variables, métodos... y en cualquier cosa relacionada con la programación.
Este no es el problema, y en principio te va a funcionar... pero todas aquellas letras y carateres que no pertenezcan al alfabeto inglés, siempre mejor evitarlos porque en determinadas situaciones pueden dar problemas.

3-º ¿Por qué estás usando un arreglo para guardar el dato del tamaño de la pizza?
Con un simple int parece que es suficiente, ya que no tienes que guardar tres tamaños de pizza al mismo tiempos. Solo necesitas guardar UN único tamaño, de entre los tres que puede elegir el usuario.
A no ser que por algún extraño motivo lo pida el enunciado (no puedo verlo, no sale la imagen), no le veo sentido usar el arreglo.

Pero bueno, vamos a suponer que obligatoriamente hay que usar el arreglo. El error que tienes es el siguiente:
Tú estás declarando el arreglo aquí
1
static int[] tamaño=new int[3];

Ahí estás indicando que ese arreglo va a tener 3 elementos.
Estos elementos van a estar numerados con los indices 0,1 y 2

Vale, pero tu luego intentas usar el arreglo de este modo:
1
2
System.out.print("Ingrese el tamaño de la pizza(1. Pequeña  2. mediana  3.Grande):  ");
    tamaño[3]=sc.nextInt();

Ahí, al poner tamaño[3], lo que dices es que el dato que has pedido se ha de guardar en el elemento que tenga como indice el numero 3.
Pero este elemento no existe, hemos dicho que tu arreglo los elementos tienen los indices: 0,1 y 2

Así que basta con que cambies ese 3, por cualquiera de los tres indices posibles, por ejemplo:

1
2
System.out.print("Ingrese el tamaño de la pizza(1. Pequeña  2. mediana  3.Grande):  ");
    tamaño[0]=sc.nextInt();
Y ese mismo cambio has de hacerlo en el resto de lineas donde estés accediendo a ese elemento del arreglo.

Pero vamos, en realidad lo ideal sería prescindir del arreglo ya que, al menos con la información que tengo ahora, no es necesario usar ningún arreglo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
sin imagen de perfil
Val: 12
Ha aumentado su posición en 6 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda con problema de pizzas

Publicado por Marthy (11 intervenciones) el 21/09/2018 01:22:49
MUY BUENA TU EXPLICACIÓN EN SERIO LO ENTENDÍ Y MUCHAS GRACIAS EN REALIDAD LO SIENTO POR EL PROBLEMA QUE NO SE VE AQUÍ ABAJO TE LO DEJO. SI ME AYUDARAS A COMPLETAR EL CÓDIGO POR FAVOR ES QUE TODAVÍA NO SE MUCHO DE ESO. DE MATRIZ Y MÉTODOS. GRACIAS ESPERO TU RESPUESTA.
---------------------------------------------------------------------------

El problema es este:

Una pizzería vende sus pizzas en tres tamaños:
- Pequeña (10 pulgadas de Diámetro )
-Mediana (12 pulgadas de Diámetro )
-Grande (16 pulgadas de Diámetro )

Una pizza puede ser sencilla (con solos salsa o carne ), o con ingredientes extras, tales como pepinillos,champiñones o cebollas. Los propietarios desean desarrollar un método que calcule el precio de venta de una pizza, dándole el tamaño y el número de ingredientes extras.
El precio de venta será 1.5 veces el costo total, que viene determinado por el área de la pizza ,más el númerode ingredientes.

En particular el costo total se calcula sumando:
- Un costo fijo de preparación (fijo,puede ponerlo como constante ).
-Un costo base variable que es proporcional al tamaño de la pizza (fijo, puede ponerlo como constante, necesitará 3)
- Un costo adicional por cada ingrediente extra. Por simplicidad se supone que cada ingrediente extra tiene el mismo costo por unidad de área (fijo, puede ponerlo como constante ).

Además se necesita saber el importe facturado por día, es decir la suma del precio de venta de los N clientes que puede recibir en el día y la ganancia del día = costo total de preparación - precio de venta, además deberá almacenar el tamaño de la pizza(1-pequeña, 2- Mediana, 3 - grande).

Para ello deberá guardar en una matriz el tamaño de la pizza, el costo total de preparación, el precio de venta, la ganancia de cada venta realizada en el día.

Al finalizar el día (cuando se decida no ingresar más ventas, el sistema imprimirá el siguiente menú:

1.- Mostrar la ganancia del día, la venta del día y el costo del día.
2.- Mostrar la ganancia del día por tamaño de pizza.
3.- Mostrar el número total de pizzas vendidas y el numero de pizzas vendidas por tamaño.
4.- Mostrar la ganancia del día, la venta del día y el costo del día por tamaño de pizza.
5.- Imprimir la matriz dónde se almacenaron las ventas(en formato matriz )
6.- Salir.

Cada vez que se ingrese los números del menú deberá realizarse la operación correspondiente , tener en cuenta que sólo cuando se ingrese el número 6 se podrá salir del sistema, caso contrario seguirá pidiendo que ingrese un número del menú. USE MÉTODOS.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
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

Ayuda con problema de pizzas

Publicado por Kabuto (979 intervenciones) el 22/09/2018 02:11:10
Hola.

OK, ya tengo enunciado, ahora si queda claro que hay que usar una matriz y por qué.

He escrito ya parte del código, dame un dia más para completarlo y poder comentartelo para que quede lo más claro posible.
Cuando esté terminado lo muestro aquí y doy algunas explicaciones.

Un saludo.
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
sin imagen de perfil
Val: 12
Ha aumentado su posición en 6 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda con problema de pizzas

Publicado por Marthy (11 intervenciones) el 22/09/2018 02:14:46
OK gracias por la ayuda. Sí por favor. Sería muy amable de tu parte. Espero tu respuesta.
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

Ayuda con problema de pizzas

Publicado por Kabuto (979 intervenciones) el 23/09/2018 02:43:48
OK, Ya lo tengo.

A ver, el enunciado es muy especifico en cuanto al proceso de mostrar datos, pero no lo es tanto respecto al proceso de obtener los datos.
Como no queda demasiado claro, yo he optado por hacer un pequeño menu de ventas de pizza para obtener los datos.
Un menu donde pide tamaño y numero ingredientes y hace la venta de la pizza.
Cuando el usuario elige finalizar el "Menu de Venta", pasamos al "Menu de cierre" que es el que está mejor especificado.

Al final de todo postearé el código completo. Pero ahora, iré poniendo el código por partes y comentandolo para intentar que quede claro el por qué de cada cosa.

Primero vamos a ver cuales son los atributos/variables principales que vamos a necesitar.
El enunciado nos indica esto:
En particular el costo total se calcula sumando:
- Un costo fijo de preparación (fijo,puede ponerlo como constante ).
-Un costo base variable que es proporcional al tamaño de la pizza (fijo, puede ponerlo como constante, necesitará 3)
- Un costo adicional por cada ingrediente extra. Por simplicidad se supone que cada ingrediente extra tiene el mismo costo por unidad de área (fijo, puede ponerlo como constante ).


Conforme a esto, to declaro estas variables como CONSTANTES.
Es decir, su valor no podrá variar durante la ejecución del programa, para ello usamos la clausula final
1
2
3
4
5
6
//Costes fijos
	final static int COSTO_PREP = 3;
	final static int COSTO_PEQ = 5;
	final static int COSTO_MED = 6;
	final static int COSTO_GRA = 8;
	final static double COSTO_ING = 0.15;

Luego el enunciado nos dice esto:
Además se necesita saber el importe facturado por día, es decir la suma del precio de venta de los N clientes que puede recibir en el día y la ganancia del día = costo total de preparación - precio de venta, además deberá almacenar el tamaño de la pizza(1-pequeña, 2- Mediana, 3 - grande).

Para ello deberá guardar en una matriz el tamaño de la pizza, el costo total de preparación, el precio de venta, la ganancia de cada venta realizada en el día.


Esta es la parte más importante del programa, esta estructura de datos será el núcleo del ejercicio. Necesitaremos una matriz donde se guardará toda la información de cada venta para luego poder consultarla y obtener los datos que nos piden en el menú final del cierre del dia.
Esta matriz viene a ser como una base de datos, donde cada entrada representa una venta.
Y por cada venta guardaremos 4 datos:
tamaño pizza, coste preparacion, precio venta y ganancia obtenida.

Para declarar una matriz hay que indicarle unas dimensiones fijas. Esto limitará la cantidad de ventas que podremos hacer.
Puesto que es un ejercicio de aprendizaje, esto no importa demasiado. Yo he optado por ponerle una dimensión de 50, más que suficiente porque para probar el ejercicio no necesitamos hacer tantas ventas.
La declaro así:
1
static double[][] matrizVentas = new double[50][4];

Es muy importante entender esto, si no lo entiendes, pregunta antes de seguir revisando el ejercicio.
Repito.
La primera dimension es 50 porque he decidido poner como limite 50 ventas.
La otra dimension es 4 porque por cada venta guadaremos cuatros datos cada uno en su propio subindice de la matriz:
tamaño --> [0], coste --> [1], precio venta --> [2] y ganancia --> [3].

Bien, si usamos la matriz para guardar ventas, significa que la primera venta se guardará en la posicion [0].
La segunda venta en la posicion [1], la siguiente en la [2]... así hasta como máximo la posicion [49]
Pero, ¿como controlo en que posicion he guardado ya ventas?

Para esto, lo ideal es declarar un "contador" de pizzas vendidas. Este contador nos servirá como indice principal para saber en que posicion de la matriz debemos guardar cada venta.
Cada venta que hagamos, una vez guardado los datos en la matriz, aumentaremos en 1 el valor del contador y así la próxima venta se guardará en el sitio correcto.

1
static int pizzasVendidas = 0;

Pues con esto, y un Scanner para pedir datos al usuario, ya tenemos las principales variables que necesitaremos para el ejercicio:
1
static Scanner sc = new Scanner(System.in);


Sigamos.
Este ejercicio pide realizar bastantes tareas distintas, para cada tarea lo reocmendable es usar un método específico, así que este jercicio tendrá varios métodos.
Pero antes de ver los métodos, quiero que veamos como ha quedado el main(), el método de ejecución del programa.
Aquí se ve claramente como el ejercicio está divido en dos partes.
Primero se hacen ventas y luego se muestra el menu de cierre.

El menu de ventas no se ve porque está escrito en un metodo separado. En el main ocupa una sola linea que consiste en un bucle while "vacio".
Este while no tiene cuerpo, lo unico que hace es evaluar su condicion y mientras esta condicion sea TRUE, seguirá repitiendo la evaluacion de la condición. Dicha condición, es en realidad el método que se encarga de vender pizzas.
Luego veremos este método, pero básicamente lo que hace es vender pizzas y devolver tras cada venta el valor TRUE para que el while siga repitiendose.
Solo cuando el usuario elige la opción de cerrar el menu de ventas, devolverá FALSE y por lo tanto el while finalizará

Al finalizar, comienza el menu de cierre.
Este menu tiene su propio while y básicamente lo que hace es dar al usuario la opcion de elegir entre 6 posibilidades. Según la opción que elija, se llamará al método correspondiente a dicha opción
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
public static void main(String[] args) {
 
		//Menu venta pizzas
		while(venderPizzas());//Esto se repite hasta que venderPizzas() devuelva FALSE a peticion del usuario.
 
		//Pasamos al menu de cierre
		int opcion = 0;
		while (opcion != 6){
			System.out.println("\n\nMENU DE CIERRE");
			System.out.println("1.- Mostrar la ganancia del día, la venta del día y el costo del día.");
			System.out.println("2.- Mostrar la ganancia del día por tamaño de pizza.");
			System.out.println("3.- Mostrar el número total de pizzas vendidas y el numero de pizzas vendidas por tamaño.");
			System.out.println("4.- Mostrar la ganancia del día, la venta del día y el costo del día por tamaño de pizza.");
			System.out.println("5.- Imprimir la matriz dónde se almacenaron las ventas(en formato matriz)");
			System.out.println("6.- Salir.");
			opcion = sc.nextInt();
			switch (opcion) {
				case 1:
					gananciasDia();
					break;
				case 2:
					gananciasTamano();
					break;
				case 3:
					totalPizzas();
					break;
				case 4:
					gananciasDiaPorTamano();
					break;
				case 5:
					mostrarMatriz();
					break;
				case 6:
					System.out.println("\n\n\tFIN DEL PROGRAMA");
					break;
				default:
					System.out.println("No se reconoce la opcion: " + opcion);
			}
		}


Como ves, el main es muy sencillo y de nuevo es importante entender como funciona antes de seguir viendo el resto del ejercicio.
Básicamente muestra dos menus: primero el de vender pizzas y después el de mostrar los datos obtenidas con las ventas.


Vamos a ver ahora el metodo que se encarga de vender pizzas.
Muestra un submenu muy sencillo, solo dos opciones: vender pizza o poner fin al menu de ventas.
Si se elige vender pizza:
1- pregunta por el tamaño y por el número de ingredientes.
2- pasa estos datos a otro metodo que se encarga de calcular el precio de venta y además tambien se encargará de guardar los datos de esta venta en la matriz de ventas.
3- Realizada la venta y guardado los datos, aumenta el contador de pizzas vendidas.
4- Devuelve TRUE para que el bucle while del main() que vimos antes, siga ejecutándose

Si se elige poner fin al menu:
1- Informa por pantalla de que este menu se acabó.
2- Devuelve FALSE para que el bucle while ponga fin a su ejecucion.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static boolean venderPizzas() {
		System.out.println("\n\tMENU DE VENTA");
		System.out.println("1- Vender una pizza");
		System.out.println("2- Finalizar el dia y pasar al menu de cierre");
		int opc = sc.nextInt();
		switch (opc) {
			case 1:
				System.out.println("\nTamaños disponibles:\n1- Pequeña\n2- Mediana\n3- Grande");
				System.out.print("Elija: ");
				int tamano = sc.nextInt();
				System.out.print("\nIndique cantidad ingredientes extra(0-Si no lleva ing. extra): ");
				int ingredientes = sc.nextInt();
				calcularVenta(tamano, ingredientes);
				//Pizza vendida, la contamos
				pizzasVendidas++;
				return true;
			case 2:
				System.out.println("\n\n\t\tDIA FINALIZADO, PASAMOS A MENU DE CIERRE\n\n");
				return false;
			default:
				System.out.println("\nOpcion equivocada\n");
				return true;
		}
	}

Ahora nos interesa ver el metodo que se encarga de calcular los valores de la venta (precio, coste y ganancia) segun el tamaño y número de ingredientes indicados por el usuario y cómo se encarga de guardarlos en la matriz.
PAra los cálculos usamos los valores CONSTANTES que definimos al principio.
Observa como para guardar los datos en la posicion correcta de la matriz, usamos la variable contador pizzasVendidas como indice.
Para mostrar por pantalla el valor de la venta, estoy usando el metodo String.format(). No se si lo conoces, en cualquier caso, no pierdas ahora demasiado tiempo pensando en él.
Este método lo que hace es dar formato al valor que mostramos en pantalla. Cuando se trabaja con numeros double o float, estos a veces al sacarlos por pantalla salen con un montón de decimales los cuales no nos sirven para nada y quedan además muy feos.
Usando este metodo, le estoy diciendo que muestre el dato redondeando a solo dos decimales para que quede más elegante.
Pero repito que esto no es importante y podemos verlo luego más tarde, de momento concentrémonos en el ejercicio que es lo importante.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static void calcularVenta(int tamano, int ingredientes) {
		//Empezamos a calcular costes...
		double costeTotal = COSTO_PREP;
		if (tamano == 1) {//Pequeña 10 pulgadas
			costeTotal += COSTO_PEQ;
			costeTotal += (10 * COSTO_ING) * ingredientes;//Si ingredientes == 0 no sumará nada
		}
		else if (tamano == 2) {//Mediana 12 pulgadas
			costeTotal += COSTO_MED;
			costeTotal += (12 * COSTO_ING) * ingredientes;
		}
		else if (tamano == 3) {//Grande 16 pulgadas
			costeTotal += COSTO_GRA;
			costeTotal += (16 * COSTO_ING) * ingredientes;
		}
		double precioVenta = costeTotal * 1.5;
		double ganancia = precioVenta - costeTotal;
		//Tenemos todos los datos. Mostramos en pantalla precio venta y luego guardamos los 4 datos en matriz
		System.out.println(String.format("\nPrecio final de venta: %.2f", precioVenta));
		matrizVentas[pizzasVendidas][0] = tamano;
		matrizVentas[pizzasVendidas][1] = costeTotal;
		matrizVentas[pizzasVendidas][2] = precioVenta;
		matrizVentas[pizzasVendidas][3] = ganancia;
	}


Bueno, ya hemos visto los dos métodos relativos a la venta de pizzas.
Uno se encarga de mostrar el menu de venta y a su vez llama al otro metodo que se encarga de calcular los datos de la venta y guardarlos en la matriz.

Ahora vienen los métodos que pide el enunciado, los encargados de recorrer la matriz para extraer la información que se nos pide en cada opción.

Lo primero que nos pide es:

1.- Mostrar la ganancia del día, la venta del día y el costo del día.

De esto se encarga el siguiente método.
Recuerda que por cada venta, guardabamos 4 datos en la matriz.
En el subindice [0] --> tamaño pizza.
En el subindice [1] --> coste total de fabricar la pizza.
En el subindice [2] --> precio de venta de la pizza.(que era igual a coste *1.5)
En el subindice [3] --> ganancia obtenida por la venta(que era precio venta - coste fabricacion)
Bien, para este metodo necesitamos acceder a los subindices 1, 2 y 3 de cada una de las ventas, que van desde el 0 hasta pizzasVendidas - 1
Por cada dato al que accedermos, lo acumulamos en las variables declaradas y luego mostramos por pantalla los totales acumulados.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static void gananciasDia() {
		double totalGanancias = 0;
		double totalVentas = 0;
		double totalCostes = 0;
		/*
		 * Recorremos la matriz desde el principio hasta el valor que nos 
		 * indica el contador pizzasVendidas que nos dice cuantas ventas 
		 * se han hecho este dia.
		 * Por cada venta, extraemos los datos necesarios y los acumulamos
		 * para obtener los totales
		 */
		for (int i = 0; i < pizzasVendidas; i++) {
			totalCostes += matrizVentas[1];
			totalVentas += matrizVentas[2];
			totalGanancias += matrizVentas[3];
		}
		//Presentamos datos
		System.out.println(String.format("\nTotal Ganancias del dia: %.2f", totalGanancias));
		System.out.println(String.format("Total Ventas del dia: %.2f", totalVentas));
		System.out.println(String.format("Total Costes del dia: %.2f", totalCostes));
	}

Luego nos pide:
2.- Mostrar la ganancia del día por tamaño de pizza.
Para ello:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public static void gananciasTamano() {
		double gananciasPeq = 0;
		double gananciasMed = 0;
		double gananciasGra = 0;
		/*
		 * Recorremos matriz hasta donde nos indique el contador pizzasVendidas.
		 * Por cada venta en la matriz, analizamos el primer dato --> [0] que nos indica
		 * el tamaño de la pizza que fue vendida. Segun el tamaño, acumulamos la ganancia --> [3]
		 * en la variable correspondiente
		 */
		for (int i = 0; i < pizzasVendidas; i++) {
			double tamano = matrizVentas[i][0];
			if (tamano == 1)
				gananciasPeq += matrizVentas[i][3];
			else if (tamano == 2)
				gananciasMed += matrizVentas[i][3];
			else if (tamano == 3)
				gananciasGra += matrizVentas[i][3];
		}
		//Presentamos datos
		System.out.println(String.format("\nTotal ganancias por pizzas Pequeñas: %.2f", gananciasPeq));
		System.out.println(String.format("Total ganancias por pizzas Medianas: %.2f", gananciasMed));
		System.out.println(String.format("Total ganancias por pizzas Grandes: %.2f", gananciasGra));
	}

Opcion 3:
[i]3.- Mostrar el número total de pizzas vendidas y el numero de pizzas vendidas por tamaño.


Lo hacemos con:
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
public static void totalPizzas() {
		/*
		 * El total de pizzas vendidas nos lo indica el contador pizzasVendidas.
		 * Para saber el total de cada tamaño de pizza, usaremos tres contadores más.
		 * Recorreremos la matriz y según el primer dato --> [0] de cada venta, sabremos el
		 * tamaño de pizzas de dicha venta y aumentaremos el contador correspondiente
		 */
		int totalPequenas = 0;
		int totalMedianas = 0;
		int totalGrandes = 0;
		for (int i = 0; i < pizzasVendidas; i++) {
			double tamano = matrizVentas[i][0];
			if (tamano == 1)
				totalPequenas++;
			else if (tamano == 2)
				totalMedianas++;
			else if (tamano == 3)
				totalGrandes++;
		}
		//Presentamos datos
		System.out.println("\nTotal pizzas vendidas: " + pizzasVendidas);
		System.out.println("Total pizzas pequeñas: " + totalPequenas);
		System.out.println("Total pizzas medianas: " + totalMedianas);
		System.out.println("Total pizzas grandes: " + totalGrandes);
	}

Siguiente opcion:
[i]4.- Mostrar la ganancia del día, la venta del día y el costo del día por tamaño de pizza.


Resolvemos con:
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
public static void gananciasDiaPorTamano() {
		/*
		 * El proceso es similar al metodo de la opcion 1, gananciasDia()
		 * Pero esta vez hay que calcular por separado para cada tamaño de pizza.
		 * Necesitamos ganancias dia, ventas dia y costes de dia.. por cada uno de los 3 tamaños.
		 * Esto implica usar 6 variables distintas, aunque podemos simplificarlo usando 3 arreglos
		 * de longitud [3]. El elemento 0 será para pizzas pequeñas, elemento 1 para medianas y 
		 * elemento 2 para las grandes.
		 */
		double[] totalGanancias = new double[3];//Tres elementos, porque hay tres tamaños de pizza
		double[] totalVentas = new double[3];
		double[] totalCostes = new double[3];
		//Recorremos matriz para buscar los datos
		for (int i = 0; i < pizzasVendidas; i++) {
			double tamano = matrizVentas[i][0];
			if (tamano == 1) {
				totalCostes[0] += matrizVentas[i][1];
				totalVentas[0] += matrizVentas[i][2];
				totalGanancias[0] += matrizVentas[i][3];
			}
			else if (tamano == 2) {
				totalCostes[1] += matrizVentas[i][1];
				totalVentas[1] += matrizVentas[i][2];
				totalGanancias[1] += matrizVentas[i][3];
			}
			else if (tamano == 3) {
				totalCostes[2] += matrizVentas[i][1];
				totalVentas[2] += matrizVentas[i][2];
				totalGanancias[2] += matrizVentas[i][3];
			}
		}
		//Presentamos datos
		System.out.println("\n\tDatos por tamaños de pizza.");
		System.out.println("\nPEQUEÑAS");
		System.out.println(String.format("Total Ganancias del dia: %.2f", totalGanancias[0]));
		System.out.println(String.format("Total Ventas del dia: %.2f", totalVentas[0]));
		System.out.println(String.format("Total Costes del dia: %.2f", totalCostes[0]));
		System.out.println("\nMEDIANAS");
		System.out.println(String.format("\nTotal Ganancias del dia: %.2f", totalGanancias[1]));
		System.out.println(String.format("Total Ventas del dia: %.2f", totalVentas[1]));
		System.out.println(String.format("Total Costes del dia: %.2f", totalCostes[1]));
		System.out.println("\nGRANDES");
		System.out.println(String.format("\nTotal Ganancias del dia: %.2f", totalGanancias[2]));
		System.out.println(String.format("Total Ventas del dia: %.2f", totalVentas[2]));
		System.out.println(String.format("Total Costes del dia: %.2f", totalCostes[2]));
	}

Ultima opcion que requiere método:
[i]5.- Imprimir la matriz dónde se almacenaron las ventas(en formato matriz )

Lo hacemos así:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static void mostrarMatriz() {
		/*
		 * Simplemente recorremos la matriz y mostramos los datos intentando que
		 * salgan por pantalla como si fuera una "tabla". Es decir, cada fila de
		 * la tabla representará una venta y cada columna mostrará uno de los cuatro
		 * datos que hemos almacenado de cada venta: tamaño de pizza, coste, venta y ganancia
		 * 
		 * Para ello, necesitaremos dos bucles for anidado, uno recorrerá las "filas" y el
		 * anidado recorrerá las "columnas"
		 */
		System.out.println("\n\tMATRIZ DE VENTAS\n");
		System.out.println("TAMÑO\tCOSTE\tVENTA\tGANANC");
		System.out.println("-----\t-----\t-----\t------");
		for (int i = 0; i < pizzasVendidas; i++) {
			for (int j = 0; j < 4; j++) {
				System.out.print(String.format("%.2f\t", matrizVentas[i][j]));
			}
			System.out.println();
		}
	}

Y esto es todo.
Como ves, la clave esta en tener claro en cual de los 4 subindices de la matriz hemos guardado cada dato y acceder a ellos según lo que nos pida cada opción del menú.

Se que es mucho código a simple vista, pero en realidad no es tanto.
Miralo con detenimiento, ves por partes.. si por ejemplo no te ha quedado claro como funciona el menu de ventas, no pases a intentar a entender los siguientes metodos.
Pregunta lo que necesites y te lo explicaré lo mejor que pueda.

A continuación te pongo el código completo, listo para copiarlo, compilarlo y ejecutarlo para que lo veas funcionar.
Ya trae de por sí varior comentarios explicando cada paso.
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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
package pizzeria;
 
import java.util.Scanner;
 
public class Examen_Pizzas {
 
	static Scanner sc = new Scanner(System.in);
 
	//Costes fijos
	final static int COSTO_PREP = 3;
	final static int COSTO_PEQ = 5;
	final static int COSTO_MED = 6;
	final static int COSTO_GRA = 8;
	final static double COSTO_ING = 0.15;
 
	/*
	 * A continuacion declaramos matriz donde se almacenan las ventas.
	 * Obligatoriamente hay que darle unas dimensiones fijas.
	 * Una dimensión será: 4, ya que de cada venta hay que guardarse 4 datos:
	 * Tamaño pizza, coste preparacion precio venta, ganancia de la venta.
	 * 
	 * La otra dimensión indicará cuantas de estas ventas se podrán almacenar como máximo.
	 * Podemos poner 50, puesto que es un ejercicio de parendizaje y de todos modos no vamos
	 * a alcanzar dicha cifra de ventas.
	 * 
	 * Puesto que se guardarán datos relativos a costes de dinero, es decir, moneda fraccionaria
	 * usaremos el tipo de dato double para trabajar con decimales.
	 */
	static double[][] matrizVentas = new double[50][4];
 
	/*
	 * Nos será util un contador de pizzas vendidas a lo largo del dia.
	 * Además nos servirá como indice para saber en que posicion de la matriz (entre 0 y 49)
	 * hemos de guardar los 4 datos de cada venta.
	 */
	static int pizzasVendidas = 0;
 
	//Metodos para menu de venta de pizza
 
	/**
	 * Este metodo se encarga de llevar a cabo la venta de una pizza.
	 * Solicita los datos necesarios y los pasará al metodo calcularVenta()
	 * quien se encargará de hacer todos los calculos y guardar datos en la matriz.
	 * Este metodo devolverá siempre el valor TRUE, hasta que el usuario indique 
	 * que quiere terminar la sesión de ventas, en cuyo caso devolverá FALSE.
	 * @return TRUE si el proceso de ventas ha de continuar.
	 * 		   FALSE si el proceso de ventas ha de finalizar.
	 */
	public static boolean venderPizzas() {
		System.out.println("\n\tMENU DE VENTA");
		System.out.println("1- Vender una pizza");
		System.out.println("2- Finalizar el dia y pasar al menu de cierre");
		int opc = sc.nextInt();
		switch (opc) {
			case 1:
				System.out.println("\nTamaños disponibles:\n1- Pequeña\n2- Mediana\n3- Grande");
				System.out.print("Elija: ");
				int tamano = sc.nextInt();
				System.out.print("\nIndique cantidad ingredientes extra(0-Si no lleva ing. extra): ");
				int ingredientes = sc.nextInt();
				calcularVenta(tamano, ingredientes);
				//Pizza vendida, la contamos
				pizzasVendidas++;
				return true;
			case 2:
				System.out.println("\n\n\t\tDIA FINALIZADO, PASAMOS A MENU DE CIERRE\n\n");
				return false;
			default:
				System.out.println("\nOpcion equivocada\n");
				return true;
		}
	}
 
	/**
	 * Recibe como parametros el tamaño de la pizza y el numero de ingredientes
	 * para calcular coste de produccion, precio de venta y ganancia obtenida.
	 * Guardará dichos datos en la matriz de ventas e informa por pantalla del
	 * importe de la venta.
	 * @param tamano Tamaño de la pizza(1-pequeña, 2-mediana, 3-grande)
	 * @param ingredientes Cantidad de ingredientes extra.
	 */
	public static void calcularVenta(int tamano, int ingredientes) {
		//Empezamos a calcular costes...
		double costeTotal = COSTO_PREP;
		if (tamano == 1) {//Pequeña 10 pulgadas
			costeTotal += COSTO_PEQ;
			costeTotal += (10 * COSTO_ING) * ingredientes;//Si ingredientes == 0 no sumará nada
		}
		else if (tamano == 2) {//Mediana 12 pulgadas
			costeTotal += COSTO_MED;
			costeTotal += (12 * COSTO_ING) * ingredientes;
		}
		else if (tamano == 3) {//Grande 16 pulgadas
			costeTotal += COSTO_GRA;
			costeTotal += (16 * COSTO_ING) * ingredientes;
		}
		double precioVenta = costeTotal * 1.5;
		double ganancia = precioVenta - costeTotal;
		//Tenemos todos los datos. Mostramos en pantalla precio venta y luego guardamos los 4 datos en matriz
		System.out.println(String.format("\nPrecio final de venta: %.2f", precioVenta));
		matrizVentas[pizzasVendidas][0] = tamano;
		matrizVentas[pizzasVendidas][1] = costeTotal;
		matrizVentas[pizzasVendidas][2] = precioVenta;
		matrizVentas[pizzasVendidas][3] = ganancia;
	}
 
	//Metodos para menu de cierre
 
	/**
	 * Muestra el total diario de ganancias, ventas y coste 
	 */
	public static void gananciasDia() {
		double totalGanancias = 0;
		double totalVentas = 0;
		double totalCostes = 0;
		/*
		 * Recorremos la matriz desde el principio hasta el valor que nos 
		 * indica el contador pizzasVendidas que nos dice cuantas ventas 
		 * se han hecho este dia.
		 * Por cada venta, extraemos los datos necesarios y los acumulamos
		 * para obtener los totales
		 */
		for (int i = 0; i < pizzasVendidas; i++) {
			totalCostes += matrizVentas[i][1];
			totalVentas += matrizVentas[i][2];
			totalGanancias += matrizVentas[i][3];
		}
		//Presentamos datos
		System.out.println(String.format("\nTotal Ganancias del dia: %.2f", totalGanancias));
		System.out.println(String.format("Total Ventas del dia: %.2f", totalVentas));
		System.out.println(String.format("Total Costes del dia: %.2f", totalCostes));
	}
 
	/**
	 * Muestra el total diario de ganancias por cada tipo 
	 * de tamaño de pizza.
	 */
	public static void gananciasTamano() {
		double gananciasPeq = 0;
		double gananciasMed = 0;
		double gananciasGra = 0;
		/*
		 * Recorremos matriz hasta donde nos indique el contador pizzasVendidas.
		 * Por cada venta en la matriz, analizamos el primer dato --> [0] que nos indica
		 * el tamaño de la pizza que fue vendida. Segun el tamaño, acumulamos la ganancia --> [3]
		 * en la variable correspondiente
		 */
		for (int i = 0; i < pizzasVendidas; i++) {
			double tamano = matrizVentas[i][0];
			if (tamano == 1)
				gananciasPeq += matrizVentas[i][3];
			else if (tamano == 2)
				gananciasMed += matrizVentas[i][3];
			else if (tamano == 3)
				gananciasGra += matrizVentas[i][3];
		}
		//Presentamos datos
		System.out.println(String.format("\nTotal ganancias por pizzas Pequeñas: %.2f", gananciasPeq));
		System.out.println(String.format("Total ganancias por pizzas Medianas: %.2f", gananciasMed));
		System.out.println(String.format("Total ganancias por pizzas Grandes: %.2f", gananciasGra));
	}
 
	/**
	 * Muestra el total de pizzas vendidas y los totales por tamaño de pizza.
	 */
	public static void totalPizzas() {
		/*
		 * El total de pizzas vendidas nos lo indica el contador pizzasVendidas.
		 * Para saber el total de cada tamaño de pizza, usaremos tres contadores más.
		 * Recorreremos la matriz y según el primer dato --> [0] de cada venta, sabremos el
		 * tamaño de pizzas de dicha venta y aumentaremos el contador correspondiente
		 */
		int totalPequenas = 0;
		int totalMedianas = 0;
		int totalGrandes = 0;
		for (int i = 0; i < pizzasVendidas; i++) {
			double tamano = matrizVentas[i][0];
			if (tamano == 1)
				totalPequenas++;
			else if (tamano == 2)
				totalMedianas++;
			else if (tamano == 3)
				totalGrandes++;
		}
		//Presentamos datos
		System.out.println("\nTotal pizzas vendidas: " + pizzasVendidas);
		System.out.println("Total pizzas pequeñas: " + totalPequenas);
		System.out.println("Total pizzas medianas: " + totalMedianas);
		System.out.println("Total pizzas grandes: " + totalGrandes);
	}
 
	/**
	 * Muestra total de ganancias, ventas y costes diarios, pero
	 * separado según el tamaño de cada pizza.
	 */
	public static void gananciasDiaPorTamano() {
		/*
		 * El proceso es similar al metodo de la opcion 1, gananciasDia()
		 * Pero esta vez hay que calcular por separado para cada tamaño de pizza.
		 * Necesitamos ganancias dia, ventas dia y costes de dia.. por cada uno de los 3 tamaños.
		 * Esto implica usar 6 variables distintas, aunque podemos simplificarlo usando 3 arreglos
		 * de longitud [3]. El elemento 0 será para pizzas pequeñas, elemento 1 para medianas y 
		 * elemento 2 para las grandes.
		 */
		double[] totalGanancias = new double[3];//Tres elementos, porque hay tres tamaños de pizza
		double[] totalVentas = new double[3];
		double[] totalCostes = new double[3];
		//Recorremos matriz para buscar los datos
		for (int i = 0; i < pizzasVendidas; i++) {
			double tamano = matrizVentas[i][0];
			if (tamano == 1) {
				totalCostes[0] += matrizVentas[i][1];
				totalVentas[0] += matrizVentas[i][2];
				totalGanancias[0] += matrizVentas[i][3];
			}
			else if (tamano == 2) {
				totalCostes[1] += matrizVentas[i][1];
				totalVentas[1] += matrizVentas[i][2];
				totalGanancias[1] += matrizVentas[i][3];
			}
			else if (tamano == 3) {
				totalCostes[2] += matrizVentas[i][1];
				totalVentas[2] += matrizVentas[i][2];
				totalGanancias[2] += matrizVentas[i][3];
			}
		}
		//Presentamos datos
		System.out.println("\n\tDatos por tamaños de pizza.");
		System.out.println("\nPEQUEÑAS");
		System.out.println(String.format("Total Ganancias del dia: %.2f", totalGanancias[0]));
		System.out.println(String.format("Total Ventas del dia: %.2f", totalVentas[0]));
		System.out.println(String.format("Total Costes del dia: %.2f", totalCostes[0]));
		System.out.println("\nMEDIANAS");
		System.out.println(String.format("\nTotal Ganancias del dia: %.2f", totalGanancias[1]));
		System.out.println(String.format("Total Ventas del dia: %.2f", totalVentas[1]));
		System.out.println(String.format("Total Costes del dia: %.2f", totalCostes[1]));
		System.out.println("\nGRANDES");
		System.out.println(String.format("\nTotal Ganancias del dia: %.2f", totalGanancias[2]));
		System.out.println(String.format("Total Ventas del dia: %.2f", totalVentas[2]));
		System.out.println(String.format("Total Costes del dia: %.2f", totalCostes[2]));
	}
 
	/**
	 * Muestra todos los datos almacenado en la matriz de ventas.
	 */
	public static void mostrarMatriz() {
		/*
		 * Simplemente recorremos la matriz y mostramos los datos intentando que
		 * salgan por pantalla como si fuera una "tabla". Es decir, cada fila de
		 * la tabla representará una venta y cada columna mostrará uno de los cuatro
		 * datos que hemos almacenado de cada venta: tamaño de pizza, coste, venta y ganancia
		 * 
		 * Para ello, necesitaremos dos bucles for anidado, uno recorrerá las "filas" y el
		 * anidado recorrerá las "columnas"
		 */
		System.out.println("\n\tMATRIZ DE VENTAS\n");
		System.out.println("TAMÑO\tCOSTE\tVENTA\tGANANC");
		System.out.println("-----\t-----\t-----\t------");
		for (int i = 0; i < pizzasVendidas; i++) {
			for (int j = 0; j < 4; j++) {
				System.out.print(String.format("%.2f\t", matrizVentas[i][j]));
			}
			System.out.println();
		}
	}
 
	public static void main(String[] args) {
 
		//Menu venta pizzas
		while(venderPizzas());//Esto se repite hasta que venderPizzas() devuelva FALSE a peticion del usuario.
 
		//Pasamos al menu de cierre
		int opcion = 0;
		while (opcion != 6){
			System.out.println("\n\nMENU DE CIERRE");
			System.out.println("1.- Mostrar la ganancia del día, la venta del día y el costo del día.");
			System.out.println("2.- Mostrar la ganancia del día por tamaño de pizza.");
			System.out.println("3.- Mostrar el número total de pizzas vendidas y el numero de pizzas vendidas por tamaño.");
			System.out.println("4.- Mostrar la ganancia del día, la venta del día y el costo del día por tamaño de pizza.");
			System.out.println("5.- Imprimir la matriz dónde se almacenaron las ventas(en formato matriz)");
			System.out.println("6.- Salir.");
			opcion = sc.nextInt();
			switch (opcion) {
				case 1:
					gananciasDia();
					break;
				case 2:
					gananciasTamano();
					break;
				case 3:
					totalPizzas();
					break;
				case 4:
					gananciasDiaPorTamano();
					break;
				case 5:
					mostrarMatriz();
					break;
				case 6:
					System.out.println("\n\n\tFIN DEL PROGRAMA");
					break;
				default:
					System.out.println("No se reconoce la opcion: " + opcion);
			}
		}
 
	}
 
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
sin imagen de perfil
Val: 12
Ha aumentado su posición en 6 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda con problema de pizzas

Publicado por Marthy (11 intervenciones) el 23/09/2018 02:58:32
Wao lo hiciste amigo
En serio gracias por todo :)
Lo comenzaré a leer poco a poco
Quisiera contactarte pero no se como
Un correo tal vez?
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

Ayuda con problema de pizzas

Publicado por Kabuto (979 intervenciones) el 23/09/2018 12:02:47
Prefiero responder a cualquier duda aquí en foros, para que todo el mundo pueda participar, aportar y beneficiarse de lo que vayamos haciendo.
Además no puedo garantizar una conversación fluida y constante. Mi trabajo me ocupa la mayor parte del tiempo durante la semana y algunas noches, cuando puedo, visito foros como este un par de horas antes de irme a dormir.
Pero solo cuando puedo, a veces pasan dias sin que me sea posible.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar