Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - Kabuto

Páginas: 1 ... 26 27 28 29 30 [31] 32 33 34 35 36 ... 50
601
Aprender a programar desde cero / Re: Ayuda para ejercicio
« en: 30 de Octubre 2020, 00:52 »
Para ese caso, puedes pasarle al método como argumento el valor que nos ha dado el usuario y usarlo para la longitud de las palabras.

De hecho, para ver como funcionan ambas posibilidades, puedes "sobrecargar" ese método con esta variante que comentamos.

"Sobrecargar" un método/función en programación significa escribir una o más variantes de ese método, conservando el mismo nombre, pero cambiando los argumentos que va a recibir entre paréntesis, ya sea el tipo y/o la cantidad que recibe.

Así, el método GenerarPalabra tendrá dos variantes.
Una, no recibe ningún argumento, y entonces la longitud de las palabras se deciden al azar.

Otra, la longitud de las palabras se recibe como argumento, así que ahora ya no se emplea un Random para decidir la longitud

Este sería el código, con los dos métodos y en el main se invoca a ambos para ver la diferencia:
Código: [Seleccionar]
public class Generador {

public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);

System.out.print("Introduce el número de palabras que quieres que aparezcan: ");
int num = Integer.parseInt(teclado.nextLine());

System.out.println("\nPalabras con longitud al azar:");
for (int i = 0; i < num; i++)
System.out.println("La palabra generada es: "+ GenerarPalabra());

System.out.println("\nPalabras con longitud: " + num);
for (int i = 0; i < num; i++)
System.out.println("La palabra generada es: "+ GenerarPalabra(num));

teclado.close();
}

public static String GenerarPalabra(){
//La variable palabra almacena el resultado final
String palabra = "";
//La longitud de la palabra la decidimos al azar
int longitud = (int)(Math.random() * 9) + 1;
//Generamos palabra
for (int i=0; i<longitud; i++){
int codigoAscii = (int)Math.floor(Math.random()*(122 -
97)+97);

//para pasar el código a carácter basta con hacer un cast a char
palabra = palabra + (char)codigoAscii;
}
return palabra;
}

public static String GenerarPalabra(int longitud){
//La variable palabra almacena el resultado final
String palabra = "";

//Generamos palabra
for (int i=0; i<longitud; i++){
int codigoAscii = (int)Math.floor(Math.random()*(122 -
97)+97);

//para pasar el código a carácter basta con hacer un cast a char
palabra = palabra + (char)codigoAscii;
}
return palabra;
}
}


En pantalla, tendríamos este resultado:
Citar
Introduce el número de palabras que quieres que aparezcan: 5

Palabras con longitud al azar:
La palabra generada es: vilcvoftx
La palabra generada es: pu
La palabra generada es: gycqn
La palabra generada es: ly
La palabra generada es: vtjb

Palabras con longitud: 5
La palabra generada es: qhhds
La palabra generada es: dmwfb
La palabra generada es: sloma
La palabra generada es: egnnx
La palabra generada es: qrhgd

602
No te funciona, pero... ¿Exactamente que te falla?
¿No encuentra el fichero de texto?
¿Lo encuentra pero no lo lee bien?
¿Lo lee bien pero falla al insertar los datos en la BBDD?

Aparentemente, el código parece estar bien, creo...

Lo único que me llama un poco la atención es que la primera lectura de línea se pierde.

Aquí lees la primera línea (marco en negrita):
Citar
              FileReader file1 = new FileReader("src/personas.txt");
              BufferedReader buffer1 = new BufferedReader(file1);

              String line = buffer1.readLine();

Pero lo que se haya leído, se pierde sin haber trabajado con ella, porque luego el bucle while comienzas leyendo otra vez, así que el bucle empieza a trabajar con la segunda línea.
Citar
            while((line = buffer1.readLine()) != null)
               {
                   tokens = line.split(",");
                   ID = Integer.parseInt(tokens[0]);
                   NOMBRE = tokens[1];
                   APELLIDOS= tokens[2];
          

                   String insertString = "insert into clientes (ID, NOMBRE, APELLIDOS) values ('"+ID+"', '"+NOMBRE+"', '"+APELLIDOS+"'))";
                   stmt.executeUpdate(insertString);
               }

Esto puedes evitarlo si en el bucle, haces la lectura de líneas justo al final.
En la condición del while simplemente comprueba si la línea es null. La lectura de nueva línea lo dejas para lo último, cuando ya se haya trabajado con la anterior línea leída

Citar
            while(line != null)
               {
                   tokens = line.split(",");
                   ID = Integer.parseInt(tokens[0]);
                   NOMBRE = tokens[1];
                   APELLIDOS= tokens[2];
          

                   String insertString = "insert into clientes (ID, NOMBRE, APELLIDOS) values ('"+ID+"', '"+NOMBRE+"', '"+APELLIDOS+"'))";
                   stmt.executeUpdate(insertString);
                   //Leemos siguiente línea
                   line = buffer1.readLine()
               }

603
Aprender a programar desde cero / Re:Ayuda para ejercicio
« en: 29 de Octubre 2020, 00:00 »
 :o ¡Oh!, ¿Por qué has prescindido del método generarPalabra?
En esencia era un buen método, solo había que retirarle la pregunta de cuántas palabras queremos generar y añadirle un nuevo valor Random para decidir al azar la longitud de las palabras que se generan.

Es decir, la lógica sería preguntar cuantas palabras queremos, y con este valor invocamos al método generarPalabra con un bucle tantas veces como haya indicado el usuario.
Como al método le habremos puesto un Random para decidir cuántas letras tendrá la palabra, nos mostrará palabras distintas en cada repetición.

Mira, el código podría quedar así:

Código: [Seleccionar]
public class Generador {

public static void main(String[] args) {

Scanner teclado = new Scanner(System.in);

System.out.println("Introduce el número de palabras que quieres que aparezcan: ");
int num = Integer.parseInt(teclado.nextLine());

for (int i = 0; i < num; i++)
System.out.println("La palabra generada es: "+ GenerarPalabra()); 

teclado.close();
}

public static String GenerarPalabra(){
//La variable palabra almacena el resultado final
String palabra = "";
//La longitud de la palabra la decidimos al azar
int longitud = (int)(Math.random() * 9) + 1;
//Generamos palabra
for (int i=0; i<longitud; i++){
int codigoAscii = (int)Math.floor(Math.random()*(122 -
97)+97);

//para pasar el código a carácter basta con hacer un cast a char
palabra = palabra + (char)codigoAscii;
}
return palabra;
}
}

604
Aprender a programar desde cero / Re:Ayuda para ejercicio
« en: 27 de Octubre 2020, 23:48 »
La elección del usuario las estás usando para elegir cuántas letras tendrá la palabra.
Pero no para elegir cuántas palabras generar.

La pregunta al usuario puedes hacérsela en el main, y usas el valor que te de para hacer un bucle e invocar al método GenerarPalabra() tantas veces como indique ese valor.

Si haces esto, luego dentro del método te faltaría establecer como decidir cuántas letras tendrá la palabra.
Puedes usar otro valor random, entre 1 y 8 por ejemplo. Así cada palabra tendrá una longitud distinta.

605

Citar
Hola, primero decir que la clase Arrays tiene un método llamado sort() que ordena arrays.
La verdad es que no tenia ni idea, cada dia se aprende algo nuevo,y obviamente la idea es complicarse la vida

Es conveniente familiarizarse y visitar de vez en cuando la documentación de Java.
Si buscas en Google por "Arrays Java", uno de los primeros resultados es la documentación de Oracle, enlazando la clase Arrays.
Ahí se detallan todos los métodos disponibles, y puedes ver que el método sort() tiene muchas "sobrecargas".
"Sobrecarga" es que un mismo método, cuenta con una serie de variantes según los datos que le pasemos por parámetros.
Se le puede pasar solo el array a ordenar, o el array más dos enteros para especificar que solo ordene desde una posición concreta del array hasta otra posición, o el array y un objeto Comparator para especificar cómo se han de ordenar...

Al principio la docu resulta un poco confusa, y encima está en inglés.., pero cuando te habitúas a ella resulta útil y como mínimo, te sirve para descubrir métodos ya existentes.
Luego ya puedes buscar en la red ejemplos de como usar dichos métodos.


Aclarar por último, que el método Arrays.sort() admite arrays de cualquier tipo y clase. Pero estas clases han de tener el método compareTo() sobrescrito de manera que indique cómo se han de comparar los objetos de dicha clase.
Como dije, en algún momento empezarás a escribir tus propias clases, y si quieres que se puedan ordenar/comparar, serás tú quien tendrá que escribir el código para establecer las reglas de ordenación

Clase Persona, ¿se ordenan por edad, por peso, por nombre... o por todos esos atributos?
Clase Factura, ¿se ordenan por número de factura, por fecha, por importe... o por todos esos atributos?
Clase Coche, ¿se ordenan por matrícula, por número de bastidor, por fecha fabricación.. o por todos esos atributos?

Esto lo decide y codifica el programador mediante compareTo().

Pero bueno, todo esto lo menciono para que te suene cuando llegues a estos temas, ahora  no es importante.

606
Respecto al segundo ejercicio.

Sí, con HashMap es un poquito más complicado.
Sobre todo a la hora de iterar en los elementos que contiene. Pero tampoco es tan difícil y supongo que la intención del ejercicio es precisamente familiarizarse con los HashMap.

Cada entrada del HashMap consta de dos datos, la clave "key" y el valor "value" que asociamos a esa clave.

En este caso, el nombre de la ciudad sería la clave y la temperatura sería el valor.

Como un HashMap no es una lista como los ArrayList, luego para recorrer y mostrar todas las entradas es un poco más engorroso.
En una lista, las cosas van una detrás de la otra, recorrerlas es sencilla. Empiezas por la primera y acabas por la última.

Un HashMap, como todos los Map, son un "conjunto". No hay un orden, las cosas no están delante o detrás de las demás, no hay una primera o una última, las posiciones ordinales no son aplicables.

Como verás en mi código, aún así podemos obtener un iterador, pero el código es más feo porque hay que pedirle al HashMap que nos devuelva un Set con las entradas, y que este Set nos de un iterador.
Y al iterador hay que decirle que el tipo de dato a iterar, son las Entradas de un Set de un HashMap, compuesto de un String y un Double....
La lógica es la misma, pero las instrucciones un poco más complicadas.

Eso en cuanto a listar la ciudades, registradas.


Sobre limpiar el nombre de una ciudad...
Lo ideal es hacer un método separado que se encargue específicamente de esta tarea, de eliminar de un String el símbolo indicado.

Primero he hecho un método que usaba el split() de la case String.
Así, "cortando" allá donde esté el símbolo (porque el símbolo puede estar repetido varias veces dentro del String) obtendría el String separdo en trocitos, ya sin restos del símbolo a retirar.

Luego solo habría que volver a juntar esos trocitos en un único String y retornarlo.

Este método funciona, pero he descubierto que da problemas con algunos símbolos.
Y es porque el método split() internamente usa expresiones regulares para encontrar el símbolo donde debe cortar.
Este tipo de expresiones usan algunos "metacaracteres" para encontrar patrones que coincidan con lo que busca, caracteres como:  *, ? , +,...

Entonces, si resulta que el símbolo coincide con uno de esos metacaracteres, el algoritmo no sabe como actuar en ese caso y lanza una excepción.

Así que he escrito un segundo método, usando subString() para separar la cadena en dos partes eliminando el símbolo y luego juntando esas dos partes otra vez.
Como este proceso solo permite eliminar un símbolo, y repito que puede ocurrir que una palabra tenga el símbolo a retirar varias veces repetido, pues lo que retorna cuando ha limpiado un símbolo es una llamada recursiva a sí mismo, pasando de nuevo el símbolo y la palabra que ha limpiado.

Así esta llamada recursiva se repite hasta que el método detecta que ya no queda ningún símbolo a retirar.


Una vez limpia la palabra, para modificar la entrada del HashMapa, como estamos modificando el nombre de la ciudad, y el nombre es la clave de la entrada, no se puede modificar (según creo...)
Así que lo que hago es guardar la temperatura, eliminar la entrada "vieja" y volver a crearla con el nombre ya limpio y la temperatura guardada.

Aquí dejo el código, pregunta lo que no entiendas. Un saludo.


Código: [Seleccionar]
public class CiudadesTemp {

public static void main(String[] args) {

HashMap<String, Double> datosCiudades = new HashMap<String, Double>();
Scanner teclado = new Scanner(System.in);
int opcion = 0;

do {
System.out.print("\nMenú\n");
System.out.print("****");
System.out.print("\n 1. Ingresar ciudad ");
System.out.print("\n 2. Mostrar ciudades");
System.out.print("\n 3. Limpiar ciudad");
System.out.print("\n 4. Salir");
System.out.print("\nIndicar opción: ");
opcion = Integer.parseInt(teclado.nextLine());
switch(opcion) {
case 1:
System.out.println("\nCiudad: ");
String ciudad = teclado.nextLine();
System.out.println("Temperatura: ");
double temp = Double.parseDouble(teclado.nextLine());
datosCiudades.put(ciudad, temp);
break;
case 2:
if (datosCiudades.isEmpty())
System.out.println("Aún no hay datos de ciudades");
else {
System.out.println("\nDATOS CIUDADES");
System.out.println("----- --------\n");
Iterator<HashMap.Entry<String, Double>> datos = datosCiudades.entrySet().iterator();
while(datos.hasNext()) {
HashMap.Entry<String, Double> dato = datos.next();
System.out.println("Ciudad: " + dato.getKey() + " -- Temperatura: " + dato.getValue());
}
}
break;
case 3:
System.out.println("\nLIMPIAR NOMBRE");
System.out.println("------- ------\n");
System.out.print("Nombre ciudad a limpiar: ");
String nombre = teclado.nextLine();
System.out.println("Símbolo a retirar: ");
String simbolo = teclado.nextLine();

if (datosCiudades.containsKey(nombre)) {
/*
* El nombre es una clave del HashMap.
* No se puede alterar, podemos guardar
* valor temperatura, eliminar la entrada
* con la clave "sucia", y hacer una nueva
* entrada con la clave "limpia"
*/
//Guardamos el valor de la temperatura
double valorTemp = datosCiudades.get(nombre);
//Eliminamos la entrada
datosCiudades.remove(nombre);
//Limpiamos nombre
String limpio = limpiarPalabra(nombre, simbolo);
//Nueva entrada con nombre limpio
datosCiudades.put(limpio, valorTemp);
}
else {
System.out.println("\nNo se ha encontrado ese nombre en la lista.");
System.out.println("Escríbalo incluyendo el símbolo equivocado.");
}
break;
case 4:
System.out.println("\nFIN DE PROGRAMA");
break;
default:
System.out.println("Opción equivocada");
}

}while(opcion != 4);

teclado.close();
}

private static String limpiarPalabra(String palabra, String simbolo) {

//Buscamos indice donde se encuentra el simbolo
int indice = palabra.indexOf(simbolo);

if (indice == -1) //No contiene símbolo, retornamos la misma palabra sin tocarla
return palabra;
else {
//Dividimos la palabra en dos partes, sin incluir el simbolo a retirar
//Parte1, desde primer caracter hasta donde esta el símbolo, excluyendolo
String parte1 = palabra.substring(0, indice);
//Parte2, desde caracter despues de símbolo, hasta el final
String parte2 = palabra.substring(indice+1);
//Juntamos dos partes
String nuevaPalabra = parte1.concat(parte2);

/*
* Solo hemos retirado un símbolo, podría haber más repeticiones
* del mismo símbolo en la palabra.
* Así que retornamos una llamada recursiva a este método.
* Esta recursividad se repetirá hasta que la palabra quede libre de símbolos
*/
return limpiarPalabra(nuevaPalabra, simbolo);
}


}

private static String limpiarPalabraNoUsar(String palabra, String simbolo) {

/*
* ATENCION: Este método produce excepcion si se usan
* determinados símbolos como asterisco --> *
* Se debe a que el método split() se vale de Espresiones Regulares (clase Pattern)
* para detectar el caracter que buscamos. Y Pattern
* usa algunos "metacaracteres" para detectar patrones en el String,
* por ejemplo, el asterisco o el signo de interrogación.
* Entonces, si el patrón a buscar coincide precisamente con uno de estos metacaracteres,
* la clase Pattern no sabe distinguir una cosa de la otra y lanza una excepción. 
*/


//Comprobamos que la palabra realmente contiene el símbolo
if (palabra.contains(simbolo)) {

/*
* La palabra puede contener el símbolo, una o varias veces.
* No importa, la dividimos en "trocitos" usando el símbolo
* como la posicion/es donde hay que "cortar"
*/
String[] trocitos = palabra.split(simbolo);
/*
* Tenemos los trocitos de palabra separados, ya sin símbolo.
* Hay que juntarlos otra vez y retornaremos la palabra "limpia"
*/
String limpia = "";
for (String trocito: trocitos)
limpia = limpia + trocito;

return limpia;
}
else //No contiene símbolo, retornamos la misma palabra sin tocarla
return palabra;
}

}

607
crear un programa que lea 10 palabras y las guarde en un arreglo. Se debe
mostrar las palabras ingresadas, ordenarlas en orden alfabético y luego volver a mostrar.

Hola, primero decir que la clase Arrays tiene un método llamado sort() que ordena arrays.
Pero claro, aquí lo interesante es que lo hagamos nosotros y no que Java nos lo de ya hecho.


Para ordenar un array de String necesitamos dos cosas:
- un algoritmo de ordenación.
- saber cómo comparar Strings

Algoritmo de ordenación..., hay varios, el más famosete y el primero que se suele enseñar, es el "método de la burbuja".
Consiste en recorrer el array con dos bucles anidados un número determinado de veces y comparar cada elemento con el siguiente. Si el elemento siguiente es menor (si queremos ordenar de menor a mayor) al elemento actual, se intercambian sus posiciones y se continua con los elementos siguientes.
De este modo, los elementos menores van "subiendo" por la lista hasta ponerse los primeros. Por eso le llaman "burbuja", porque las burbujas suben...
Sí, los informáticos no son muy buenos con las metáforas...  ::)

Como digo, es el más famoso y sencillo, pero también el menos eficiente. Porque como dije antes el proceso se repite un número determinado de veces. Aunque el array ya esté correctamente ordenado, el proceso seguirá haciendo comparaciones innecesarias hasta que los ciclos de los bucles terminen.

Pero bueno, para un array de 10 elementos como es este caso, nos basta y nos sobra.


Ya tendríamos método de ordenación Ahora, ¿cómo comparamos Strings?

Para ordenar alfabéticamente habría que poner primero las que empiecen por a, luego b, luego c, etc....

Y de entre todas las que empiezan por a, primero irían las que su segunda letra también es a, luego las que la segunda letra es b, etc...

Y luego habría que ver la tercera letra, la cuarta, la quinta..., tener en cuenta que no todas las palabras tienen el mismo número de letras...

Sí, es complicado. Pero no temas, no vas a tener que desarrollar un algoritmo que haga todo eso (aunque si te hace ilusión, adelante...  ;D).

Esta vez sí vamos a dejar que Java lo haga por nosotros.

TODAS las clases escritas en Java, y cuando digo TODAS, incluyo también a las que algún día escribirás tu también cuando te enseñen Programación Orientada a Objetos (POO), TODAS son y serán hijas de la clase Object, que es algo así como la superclase suprema en Java.

Esto implica que todas las clases heredan ciertos métodos comúnes que todas van a tener.

Uno de estos métodos, es el llamado compareTo(), que está destinado a que un objeto pueda compararse con otro, para determinar si son iguales o si uno es mayor que el otro o viceversa.
Este método es para que el programador le incluya un código acorde a sus clases.
Si un programador crea una clase llamada Persona, podrá alterar este método y decidir como han de compararse sus objetos Persona, si en función de la edad, o de su altura, o de su peso, o de las letras de su apellido... o de lo que el programador crea oportuno.


La clase String ya tiene este método escrito y listo para que lo usemos.
Tan solo hay que invocarlo y saber interpretar los resultados que da.

El compareTo() retorna un valor int que nos indica cuál es mayor o menor.
Si este int tiene valor 0, es que los dos String son iguales.
Si el int es un valor negativo, es decir, es menor que 0, significa que el primer elemento es menor que el segundo.
Si fuera un valor mayor que 0, entonces el primer elemento es mayor.

Un pequeño ejemplo.
Aclarar que si una palabra es "menor" que la otra, significa que la primera palabra va delante de la otra si ordenamos alfabéticamente.

Citar
String palabra1 = "Hola";
String palabra2 = "Adios";

int comparar = palabra1.compareTo(palabra2);

if (comparar == 0)
    System.out.println("Las dos palabras son iguales");
else if (comparar < 0)
    System.out.println("Palabra1 es menor que Palabra2");
else
    System.out.println("Palabra1 es mayor que Palabra2");


Bueno, pues ahora ya tenemos método de ordenación, y también un método de comparación
Y se puede completar el ejercicio.

Disculpa si me ando mucho por las ramas con tanta explicación. Pero creo importante no solo darte el código de la solución. Si no explicar por qué funciona, y cómo funciona, y de donde sale...

Porque muchos estudiantes conocen el compareTo(), pero no saben de donde sale y por qué.., y piensan que es un método mágico que les va a servir para comparar cualquier cosa. Y no es así.
Los String los compara porque alguien ya le ha escrito un código.
El resto de clases, si nosotros no le escribimos un código, no va a saber comparar nada...


En fin, aquí te pongo la solución.
Los bucles de ordenación parecen un poco liosos, pero si te fijas básicamente lo que hace es comparar los elementos que son contiguos y si el que está detrás es menor, intercambia la posición con el otro para que quede delante.

Código: [Seleccionar]
public class OrdenaPalabras {

public static void main(String[] args) {
String palabra;
Scanner leer=new Scanner(System.in);
String array[]=new String[10];

System.out.println("Introduzca 10 palabras:");

for(int i=0; i<=9; i++) {
palabra=leer.nextLine();
array[i]=palabra;
}
leer.close();

System.out.println("Las palabras ingresadas fueron: \n" + Arrays.toString(array));

//Ordenar array, usando método burbuja y compareTo()
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length - 1; j++) {
if (array[j + 1].compareTo(array[j]) < 0) {
//Elemento que está detrás es menor, intercambiamos posiciones
String aux = array[j + 1];
array[j + 1] = array[j];
array[j] = aux;
}
}
}

System.out.println("Las palabras ordenadas son: \n" + Arrays.toString(array));

}
}



608
Tú escribe lo que sepas/puedas.
Cuando lo tengas, compártelo por aquí. Así lo revisamos y te ayudamos con lo que falte.

Por si sirve de ayuda, muestro como haría yo un par de clases (que no tiene por qué ser la mejor ni la única forma de hacerlo)

La clase Producto la haría abstracta, ya que está destinada a que las otras clases hereden de ellas.
No vamos a crear simplemente "productos". Crearemos "productos refrigerados", "productos congelados", etc...

Así que Producto interesa que sea abstracta. Tendrá los tres atributos básicos que comparten todos los tipos de productos, con sus getters y setters.
Ademas tiene un método abstracto, llamado getMargenGanancia().

Al hacerlo abstracto obligamos a que las clases que vayan a heredar de Producto, tengan que sobrescribir este método, pues cada tipo de producto tiene un margen de ganancia distinto. Así, todos tendrán este método, pero cada uno tendrá un código distinto adaptado a su propio margen de ganancia.

Código: [Seleccionar]
public abstract class Producto {

private String fechaVencimiento;
private String numLote;
private float costoTratamiento;

public Producto(String fechaV, String numL, float costo) {
fechaVencimiento = fechaV;
numLote = numL;
costoTratamiento = costo;
}

public abstract float getMargenGanancia();

public String getFechaVencimiento() {
return fechaVencimiento;
}

public void setFechaVencimiento(String fechaV) {
fechaVencimiento = fechaV;
}

public String getNumLote() {
return numLote;
}

public void setNumLote(String numL) {
numLote = numL;
}

public float getCostoTratamiento() {
return costoTratamiento;
}

public void setCostoTratamiento(float costo) {
costoTratamiento = costo;
}

}

En el siguiente ejemplo, pongo la clase Refrigerado
Hereda de Producto, así que automáticamente ya tendrá los atributos y métodos de la clase madre y tendrá que sobrescribir el método getMargenGanancia() para hacer su propio cálculo de este dato. Para los Refrigerados, el margen de ganancia es el 15% respecto al costo de tratamiento (atributo que hereda de Producto)

Además, se añaden los atributos propios de esta clase, junto con sus correspondientes getters y setters.

Tiene dos constructores. Uno que recibe los datos mínimos para crear un Producto, quedando el resto de atributos (los propios de Refrigerado) con valores indefinidos.

El otro constructor, recibe todos los datos necesarios para crear un Producto Refrigerado al completo, con todos los atributos con valores definidos.

Código: [Seleccionar]
public class Refrigerado extends Producto{

private String codigoSupervision;
private String fechaEnvasado;
private int tempMantemimiento;
private String granjaOrigen;

//Constructor con atributos mínimos para crear un Producto
public Refrigerado(String fechaV, String numL, float costo) {
super(fechaV, numL, costo);
codigoSupervision = "";
fechaEnvasado = "";
tempMantemimiento = 0;
granjaOrigen = "";
}

//Constructor con todos los atributos para crear un Producto Refrigerado
public Refrigerado(String fechaV, String numL, float costo, String codigoS,
String fechaE, int tempM, String granjaO) {
super(fechaV, numL, costo);
codigoSupervision = codigoS;
fechaEnvasado = fechaE;
tempMantemimiento = tempM;
granjaOrigen = granjaO;
}

@Override
public float getMargenGanancia() {
//Margen de ganancia del 15% respecto del costo
return 15f * getCostoTratamiento() / 100;
}

public String getCodigoSupervision() {
return codigoSupervision;
}

public void setCodigoSupervision(String codigoS) {
codigoSupervision = codigoS;
}

public String getFechaEnvasado() {
return fechaEnvasado;
}

public void setFechaEnvasado(String fechaE) {
fechaEnvasado = fechaE;
}

public int getTempMantemimiento() {
return tempMantemimiento;
}

public void setTempMantemimiento(int tempM) {
tempMantemimiento = tempM;
}

public String getGranjaOrigen() {
return granjaOrigen;
}

public void setGranjaOrigen(String granjaO) {
granjaOrigen = granjaO;
}

}

El resto de clases "producto" seguirían esta dinámica de herencia.

609
Es que ahora me doy cuenta de que el enunciado no es explícito en una cosa, o quizás es que está mal planteado...

El array donde anotamos las asistencias, no puede ser un array de una sola dimensión.
Por eso te muestra los mismos resultados, porque al ser de una sola dimensión, solo guarda los datos de un único alumno.
Da igual si registras dos, cinco o quinientos alumnos... para cada uno de estos estamos usando el mismo array, así que al final de la inserción de datos, solo tendremos las últimas asistencias que se registraron.

Para las asistencias, hay que usar un array de dos dimensiones, es decir, una matriz

Su primera dimensión la establece el valor de cant_Alumnos y la segunda el valor de cant_Clases

Código: [Seleccionar]
string[,] lista_Asistencias = new string[cant_Alumnos,cant_Clases];
De este modo, ahora sí que podremos registrar las asistencias de todos los alumnos, en cada una de sus clases

610
El método crearPlanillaAsistencia() esta mal, en todos los sentidos.

Se supone que este método ha de crear o retornar un array de string, cuyo tamaño sea la "cantidad de alumnos" que el usuario haya introducido por teclado.

Pero este código no hace eso:

Citar
        public static int CrearPlanillaAsistencia(int cantidad_muestra)//1.a
        {
            int cantidad4 = 0;
            string[] cantidad_Alumnos = new string[cantidad4];
            return cantidad_muestra;

        }
- Recibe por argumentos la cantidad de alumnos (cantidad_muestra), pero no usa ese dato para nada.
- Crea un array de string, sí, pero su tamaño es 0, ya que usa la variable cantidad4, y cantidad4 = 0
- Pero da igual el tamaño del array, porque no lo está retornando. Lo único que retorna este método es el mismo dato que ha recibido por argumentos (cantidad_muestra).

Es decir, este método recibe el dato cantidad_muestra, crea un array de longitud 0 (que es lo mismo que no crear nada) y vuelve a retornar cantidad_muestra.

Hay que corregirlo, debe crear un array con el tamaño que le diga cantidad_muestra, y retornarlo.

Citar
        public static string[] CrearPlanillaAsistencia(int cantidad_muestra)//1.a
        {
            string[] cantidad_Alumnos = new string[cantidad_muestra];
            return cantidad_Alumnos;

        }

Bueno, tendríamos ya el método corregido, pero ahora hay otro problema.
Tú invocas a este método en el Main

Citar
static void Main(string[] args)
        {

            //int cant_ClasesMes = 0;
           
            int cant_Alumnos = ingresoNumericoconControl("Ingrese cantidad alumnos)");//p_1
            int cant_Clases = ingresoNumericoconControl("Ingrrese cantidad Clases");
            CrearPlanillaAsistencia(cant_Alumnos);
            TomarAsistencia(cant_Alumnos, cant_Clases); // PUNTO 1.B
        }

Pero no estás recogiendo el dato que retorna, tan solo lo invocas, así que el array de string que retorna, no se está recogiendo y se pierde.
Hay que recogerlo, por ejemplo, asignándolo a una referencia ahí en esa misma línea.

Citar
static void Main(string[] args)
        {

            //int cant_ClasesMes = 0;
           
            int cant_Alumnos = ingresoNumericoconControl("Ingrese cantidad alumnos)");//p_1
            int cant_Clases = ingresoNumericoconControl("Ingrrese cantidad Clases");
            string[] lista_Alumnos = CrearPlanillaAsistencia(cant_Alumnos);
            TomarAsistencia(cant_Alumnos, cant_Clases); // PUNTO 1.B
        }

Bien, ya tenemos el array refenciado para no perderlo. Ahora hay que pasárselo al método TomarAsistencia(), ya que los nombres de alumnos que se van a ingresar, se ha de hacer en este array que hemos creado:

Citar
static void Main(string[] args)
        {

            //int cant_ClasesMes = 0;
           
            int cant_Alumnos = ingresoNumericoconControl("Ingrese cantidad alumnos)");//p_1
            int cant_Clases = ingresoNumericoconControl("Ingrrese cantidad Clases");
            string[] lista_Alumnos = CrearPlanillaAsistencia(cant_Alumnos);
            TomarAsistencia(lista_Alumnos, cant_Clases); // PUNTO 1.B
        }

Ahora lo que hace falta, es corregir también el método TomarAsistencia().
El método que has escrito, crear dos arrays, uno para nombres y otro para las asistencias en cada clase.
Marco en rojo, algunas (no todas) de las cosas que hay que corregir.
La línea que marco en verde, no me queda claro su propósito. Es más, no estoy seguro siquiera de que el compilador la de por válida.
Citar
public static int  TomarAsistencia(int cant_alumnos, int cant_clases)
        {

           
            string[] array_Alumnos = new string[cant_alumnos];
            string[] array_Clase = new string[cant_clases];//1.b

           
            creaplanillaAssistencia: " + cantidad_muestra);
         
             for (int i = 0; i < cant_alumnos; i++)
             {
                 Console.WriteLine("Ingrese nombre alumno nº: " + i + ";");
                    array_Alumnos[i ] = Console.ReadLine();
                 for (int s = 0; s < cant_clases; s++)
                 {
                     Console.WriteLine("ingrese a ausente o p presente: " + s + ";");
                     array_Clase[s ] = Console.ReadLine();
                }
                Console.WriteLine();             
            }
             //muestra
             for (int i = 0; i < cant_alumnos; i++)
             {
                 Console.WriteLine("NOMBRE: " + array_Alumnos[i ] + " Nº: " + i);
                for (int s = 0; s < cant_clases; s++)
                {
                    Console.WriteLine("Asistencia: " + array_Clase[s ] + " Clase Nº: " + s);
                }         
              }

            return cant_alumnos;
        }

No debe crear dos arrays, debe utilizar el array creado en planillaAsistencia() y que ya le estamos pasando por parámetros y crear otro más con la cantidad de clases que también le indicamos por argumentos.

Marco en negrita las principales correcciones, para que se reciba y se pueda usar el array de string correcto.

Citar
public static int TomarAsistencia(string[] array_Alumnos, int cant_clases)
        {

           
            //Esta linea se puede borrar -- string[] array_Alumnos = new string[cant_alumnos];
            string[] array_Clase = new string[cant_clases];//1.b

           
            //Esta linea se puede borrar -- creaplanillaAssistencia: " + cantidad_muestra);
         
             for (int i = 0; i < cant_alumnos; i++)
             {
                 Console.WriteLine("Ingrese nombre alumno nº: " + i + ";");
                    array_Alumnos[i ] = Console.ReadLine();
                 for (int s = 0; s < cant_clases; s++)
                 {
                     Console.WriteLine("ingrese a ausente o p presente: " + s + ";");
                     array_Clase[s ] = Console.ReadLine();
                }
                Console.WriteLine();             
            }
             //muestra
             for (int i = 0; i < cant_alumnos; i++)
             {
                 Console.WriteLine("NOMBRE: " + array_Alumnos[i ] + " Nº: " + i);
                for (int s = 0; s < cant_clases; s++)
                {
                    Console.WriteLine("Asistencia: " + array_Clase[s ] + " Clase Nº: " + s);
                }         
              }

            return cant_alumnos;
        }


Hay más cosas que corregir. Todas las líneas que usan la variable cant_alumnos, variable que YA NO está recibiendo este método, porque NO es lo que necesita, se tienen que modificar o eliminar según sea necesario.
Habría que revisar que las demás lineas están usando correctamente el array que recibimos por parámetro, no las he mirado, así que no se si requieren correcciones.
Este método tampoco debería retornar un int, de hecho, no debería retornar nada. Tan solo mostrar en pantalla el contenido de los dos arrays una vez se han introducido todos los datos.
Estos cambios te los dejo a ti.

Corrige todo lo que hemos dicho, no se si con esto quedaría el programa completado, en cualquier caso si te surgen dudas, si faltan más cosas, si las correcciones implican nuevos problemas... lo que sea, ...pregunta por aquí y lo vemos.

Un saludo.

611
Vaaale, ahora lo pillo.

Efectivamente con split() y una matriz de enteros para usar como contadores, se puede hacer, pero de otra forma distinta a la que te explicaron, que creo es más fácil o al menos suena más lógica.

A la hora de analizar digitos, primero elegimos una posición, y luego recorremos todas las cadenas que nos ha dado el split(), analizando que dígito encontramos en esa posición.

Es decir, empezamos por la posición 0.
Pues a cada cadena, preguntamos que tiene en 0.
Y en la matriz, incrementamos contador, según la posición y el dígito encontrado
Si encontramos un '1'.
Pues en matriz[0][1] incrementamos el contador.

Cuando encontramos un '5', se incrementa matriz[0][5]
Etc...

Luego pasamos a posición 1, y repetimos el mismo proceso.
Que se encuentra un '8',.., pues se incrementará matriz[1][8]

Siempre previamente comprobando que el valor que toca analizar, tiene longitud suficiente para consultar la posición actual.


Dejo un código con varios comentarios explicando cada línea, a ver si se entiende bien, porque si es un pelín engorroso el proceso si no se está acostumbrado a trabajar con matrices.

Cualquier duda, preguntad:
Código: [Seleccionar]
public class Digitos {

public static void main(String[] args) {

//Cadena de digitos para analizar
String cadena =",12,34,56,78,34,23,45,567,3452,43246";
//Separamos los digitos de esta cadena, en varias cadenas agrupadas en array
String[] valores = cadena.split(",");

/*
* Usaremos una matriz para contar las repeticiones de digitos
* en cada posición. Pero antes tenemos que averiguar cuantas posiciones
* habrán. Esto depende de cuánto mide la cadena más larga, así que
* vamos a recorrer todas las cadenas y averiguar la longitud mayor.
*/
int mayor = 0;
for (String valor: valores)
if (valor.length() > mayor)
mayor = valor.length();

/*
* Tenemos la longitud mayor. Podemos crear la matriz.
* La primera dimensión la indica la longitud mayor, es decir,
* cuántas posiciones vamos a evaluar.
* La segunda dimensión será el valor 10, porque cada posición
* puede contener 10 posibles digitos (0 a 9)
*/
int[][] repeticiones = new int[mayor][10];

/*
* Ahora recorremos cada posición de cada cadena, con bucles anidados,
* teniendo en cuenta que no todas las cadenas miden lo mismo
* y algunas tendrán posiciones que otras no tienen.
* Evaluaremos el digito encontrado en cada posición y lo contaremos
* en el espacio adecuado de la matriz.
*/

for (int posicion = 0; posicion < mayor; posicion++) {
for (String valor: valores) {
/*
* Primero comprobamos si la posición actual
* está dentro del rango de tamaño de este valor
*/
if (posicion < valor.length()) {
switch (valor.charAt(posicion)) {
case '0'://Incrementamos contador e matriz, según la posicion y digito
repeticiones[posicion][0]++;
break;
case '1':
repeticiones[posicion][1]++;
break;
case '2':
repeticiones[posicion][2]++;
break;
case '3':
repeticiones[posicion][3]++;
break;
case '4':
repeticiones[posicion][4]++;
break;
case '5':
repeticiones[posicion][5]++;
break;
case '6':
repeticiones[posicion][6]++;
break;
case '7':
repeticiones[posicion][7]++;
break;
case '8':
repeticiones[posicion][8]++;
break;
case '9':
repeticiones[posicion][9]++;
break;
}
}
}
//Ya se han analizado todos los valores en esta posición.
//Se repite mismo proceso, en la siguiente posición
}

/*
* Ya se han recorrido todos los valores de la cadena de números
* y tenemos la repetición de cada digito en cada posición.
* Recorremos la matriz para mostrar resultados.
*/

for (int posicion = 0; posicion < repeticiones.length; posicion++) {
System.out.println("\nPosicion " + (posicion + 1));
for (int digito = 0; digito < 10; digito++)
if (repeticiones[posicion][digito] > 0) {
System.out.print("Número: " + digito);
System.out.println(" -- Cantidad: " + repeticiones[posicion][digito]);
}
}

}

}

612
Gracias por la parte que me toca...

Decir que fue aquí, en esta página, donde encontré la semillita para aprender Java y programación moderna.

Yo estudié programación en mi época de instituto, pero era un temario absolutamente desfasado de una FPII que estaba siendo retirada y basada en programación secuencial.
Cobol, Turbo Pascal, Clipper..., ni siquiera entraba C aunque algunos profesores se saltaron el temario y nos dieron algunas nociones de este lenguaje porque ellos mismos se sentían culpables (y no era culpa de ellos) de lanzarnos al mercado laboral en estas condiciones.
Era el año 2001, pleno comienzo del nuevo siglo, con Internet, HTML, Acces, Visual Basic,... en pleno auge y nosotros (mi promoción) íbamos a entrar en él con herramientas casi de los años 80.

Obviamente no me dediqué a la programación, encontré otros caminos.., pero me quede con la espina de no haber salido con mejor base, con mejores conocimientos para programar aunque sea por afición, algo más acorde a los tiempos que manejar registros de Cobol en modo consola.

Y durante muchos años intenté aprender por mi cuenta pero no daba con la tecla. En serio, probé muchas páginas, tutoriales.., en todos acababa desorientándome y abandonando hasta el siguiente intento.

Y un día me topé con esta página que sí supo explicarme la POO de forma que un desfasado y pésimo autodidacta como yo pudiera entenderlo, y familiarizarme con lenguajes modernos como Java. (aunque quizás hoy día ya no lo sea tanto...)

Eso me allanó el camino para seguir aprendiendo y avanzando.

Y de ahí que le tenga cariño a esta página e intente devolver el favor. Y ayudar a otros que empiezan en la programación, porque yo no olvido que al principio ninguno sabemos de lógica de la programación, a todos nos cuesta entender ciertos conceptos y que necesitamos algo más que un simple enlace a la API de Java en inglés.


Bueno, que el agradecido soy yo  ;).
Un saludo a toda la comunidad.

613
Eemm.. pues no termino de entender el propósito a cumplir...supongo que la salida que has puesto de ejemplo, son datos al azar y no tienen que ver con la cadena propuesta.., porque no veo la relación entre ambos...

A ver, supongamos que la cadena es mucho más sencilla:

Código: [Seleccionar]
String cadena =",12,34";
¿Que salida deberíamos tener?

614
Mira, un posible UML podría ser este.
Solo pongo los atributos, los métodos serían prácticamente getters y setters.
El margen de ganancia de cada clase lo pongo como comentario al UML, luego al implementar el código habría que decidir si es otro atributo más, o simplemente lo tenemos en cuenta para la función que calcula el margen de ganancia para cada lote...esto ya es a gusto del programador...


615
No se si se logra entender pero no me da la opción de ingresar la palabra como muy bien tu indicas.

Hola.

Siempre que en un mismo código queramos leer valores numéricos y cadenas String con Scanner, vamos a tener el problema que mencionáis.

Tras leer un valor numérico, si al siguiente lectura queremos leer un String, esta lectura fallará.

Para evitarlo, lo ideal es hacer SIEMPRE la lectura de cualquier dato con nextLine(), para obtener un String completo.
Y si lo que queremos es un valor numérico, entonces parseamos (transformamos) ese String al tipo de dato que queremos.

Por ejemplo:

Citar
do {
         menu();
         opcion=sc.nextInt();

Ese nextInt() nos da un entero, pero va a impedir que luego podamos leer un String con nextLine().

Para evitar este problema, podemos leer el entero de la siguiente forma:

Citar
do {
         menu();
         opcion=Integer.parseInt(sc.nextLine());

Esa línea lo que hace es leer un String, y automáticamente lo transforma a un entero que es lo que realmente deseamos.
Y de este modo si luego queremos leer otro String, veremos que no tenemos ningún problema.

Puede parecer un poco complicado, pero es la mejor forma (no la única) de evitar este problema, que también ocurre en otros lenguajes como C y C# y se soluciona de forma similar.

616
Al margen del lenguaje, lo primero es identificar cuáles son las clases que van a intervenir.

Está claro que habrá una superclase Producto.

De esta heredarán tres clases: Refrigerado, Congelado, Fresco.

De Congelado heredarán otras tres: PorAire, PorAgua y PorNitrogeno.

De Fresco heredan dos más: Organico y Standard


Luego podría haber una clase llamada Stock que incluya a la clase Lote (no es un relación de herencia, si no de inclusión).

Es decir, tendríamos un único objeto Stock, que incluiría N objetos Lote, que a su vez cada uno incluiría N objetos de la familia de clases Producto.

Todo esto es lo que hay que organizar antes de empezar nada. Ya sea con un diagrama UML, o bien de cualquier otra forma que a ti te sirva para aclararte las ideas.

Identificar las clases, que atributos y métodos tiene cada una y como se relacionan entre ellas (herencia, inclusión...)

Con todo esto clarificado, se puede empezar a escribir código, sea el lenguaje que sea.


617
Comunidad / Re:Presentacion
« en: 15 de Octubre 2020, 19:19 »
Te doy la bienvenida, aunque con retraso.... :-[
He estado como 3 semanas sin línea de Internet y apartado de foros.

Pues eso, bienvenido.. ;)

618
Estoy poco familiarizado con C y aún menos con esto de los punteros.

Así que la solución que doy no se si es la correcta, pero bueno, lo que es ordenar números sí que lo hace.
Además de completar la función, he cambiado el orden de las primeras líneas, porque si no producía un efecto extraño, el programa comienza a pedir datos sin antes mostrar los texto de los printf(), mostrándolos después de haber insertado los tres valores:

Código: [Seleccionar]
#include<stdio.h>

void pro(int *a, int *b , int *c);
int aa, bb, cc, *apuntador1, *apuntador2, *apuntador3;

int main(){

printf("\nIntroduce el valor de a:");
scanf("%d",&aa);
printf("Introduce el valor de b:");
scanf("%d",&bb);
printf("Introduce el valor de c:");
scanf("%d",&cc);

apuntador1 =&aa;
apuntador2 =&bb;
apuntador3 =&cc;

printf("\na=%d, b=%d, c=%d",aa, bb, cc);

pro(&aa,&bb,&cc);

printf("\na=%d, b=%d, c=%d",*apuntador1,*apuntador2,*apuntador3);

return 0;
}
void pro(int *a, int *b, int *c){//funcion que ordena  los números ingresados por el usuario de mayor a menor


if(*a<*b && *b<*c){
//Nada que hacer, ya están en orden
}else if (*a<*c && *c<*b){
int temp = *c;
*c = *b;
*b = temp;
}else if (*b<*a && *a<*c){
int temp = *b;
*b = *a;
*a = temp;
}else if (*b<*c && *c<*a){
int temp = *a;
*a = *b;
*b = *c;
*c = temp;
}else if (*c<*a&& *a<*b){
int temp = *c;
*c = *b;
*b = *a;
*a = temp;
}else if (*c<*b&& *b<*a){
int temp = *c;
*c = *a;
*a = temp;
}
}

619
Comunidad / Re:programación
« en: 17 de Septiembre 2020, 00:20 »
Hola y bienvenido.

En la web de este foro hay libros a la venta para iniciarse y también distintos cursos gratuitos.

Si tu objetivo es crear juegos, hay que decir que ello conlleva dominar varias disciplinas, no solo programación.

Pero sí, la programación será necesaria.

Lo recomendable primero es practicar con pseudocódigo, para aprender los conceptos básicos de la lógica de la programación, sin tener que pelearse al mismo tiempo por dominar un lenguaje de programación en concreto.
Para pseudocódigo no se necesita ningún programa especial, porque no es un lenguaje real. Se puede hacer con el bloc de notas, o con papel y lápiz... porque no son programas que se puedan ejecutar.
Son ejercicios escritos, usando unas palabras en nuestro idioma que simulan las instrucciones de un lenguaje, pero todo más simplificado como digo, para centrarnos en aprender lógica y no un lenguaje.

Al principio puede ser aburrido, porque todos queremos hacer programas que se ejecuten y el ordenador haga lo que le hemos pedido.
Pero es un paso necesario, que de hecho cada vez menos gente lo hace  :(

Veo en los foros gente que ha aprendido las instrucciones de un lenguaje, ya sea Java, C, Python... pero no sabe que hacer con ellas. No sabe como aplicarlas, porque no ha aprendido lógica de la programación, ni algoritmia, ni nada...

Cuando ya se esta familiarizado con esos conceptos básicos: qué es una variable, una expresión, un condicional, un bucle...
es cuando podemos elegir un lenguaje para reafirmar estos conceptos aprendidos y seguir avanzando.


Sobre elegir lenguaje de programación, pues bueno, eso va un poco a gustos.
A mi me gusta Java para aprender, es potente, orientado a objetos y sin las complicaciones que otros lenguajes tienen, lenguajes más potentes sí, pero es una potencia que para la programación más habitual no vamos a necesitar.

Tiene una documentación muy buena y un montón de librerías estandarizadas. Da igual que sistema operativo y/o programa compilador se utilice, las instrucciones Java serán las mismas en todos los casos.

Además, si luego quisieras programar para Android, sabiendo Java ya tendrías la base ideal.

Sin embargo, si tu objetivo es hacer videojuegos, quizás te interesen más otros lenguajes como C++ o C#, este último está muy ligado a Unity, un motor para crear videojuegos de corte profesional de forma relativamente sencilla.

De todos modos, C++, C# y Java comparten una sintaxis muy parecida (son primos hermanos) así que aprendiendo uno, luego es muy fácil familiarizarse con los otros.

C++ es quizás un poco más "rústico" para intentar dominarlo desde un principio.
Yo escogería entre Java y C#...y cuando ya seas nivel pro  ;) comenzaría a tantear C++

620
Hola.

He probado esos 4 ejercicio y parecen funcionar bien.
No veo errores.

Si alguno de esos te está fallando, concrétanos el error que te da.

Un saludo.

Páginas: 1 ... 26 27 28 29 30 [31] 32 33 34 35 36 ... 50

Sobre la educación, sólo puedo decir que es el tema más importante en el que nosotros, como pueblo, debemos involucrarnos.

Abraham Lincoln (1808-1865) Presidente estadounidense.

aprenderaprogramar.com: Desde 2006 comprometidos con la didáctica y divulgación de la programación

Preguntas y respuestas

¿Cómo establecer o cambiar la imagen asociada (avatar) de usuario?
  1. Inicia sesión con tu nombre de usuario y contraseña.
  2. Pulsa en perfil --> perfil del foro
  3. Elige la imagen personalizada que quieras usar. Puedes escogerla de una galería de imágenes o subirla desde tu ordenador.
  4. En la parte final de la página pulsa el botón "cambiar perfil".