Java simular memoria con n palabras de cierta longitud usando arrays (arreglos)

[Kadistu]

Saludos a todos,, tengo el siguiente problema:

Para un arreglo de Strings de tamaño 100 y que esta inicial izado con la letra "H", requiero cargar en el arreglo una letra del abecedario la cantidad de veces que el usuario indique.

El programa solo cargara la letra del usuario en el  espacio o espacios  que sean igual a "H" que serán los espacios disponibles, si un espacio esta ocupado por una letra distinta a "H" el programa deberá avanzar en el arreglo hasta encontrar un espacio igual a "H".

no logro establecer la condición correcta para esto que les cuento.

si alguien me puede ayudar se lo agradecería, aquí esta el código del programa que tengo..

Código: [Seleccionar]

import javax.swing.JOptionPane;

public class Memoria {
    String [] memoriatotal = new String [100];
    String nombre1="";
    public void inicializarmemoria(){ //con letra H
        for(int i=0;i<100;i++){
            memoriatotal [i] = "H";//
            }
    }//fin inicializarmemoria
    public void cargarProceso() {
       int espacios,n=0;
        String dato="H",numero1;
            nombre1= JOptionPane.showInputDialog("Digite Letra del Abecedario: " );
            String linea = nombre1.toUpperCase();
            if(!linea.equals("H")){
                numero1= JOptionPane.showInputDialog("Digite la cantidad de veces que se imprimira la Letra: " );             
                n= Integer.parseInt(numero1);
                    for(int c=0; c<5;c++){
                       
                           espacios=n;
                            if(memoriatotal[c].equals(dato)){
                                for( int d=0; d<espacios;d++){
                                    memoriatotal[d]= linea;
                                     if(!memoriatotal[c].equals(dato))
                                        for( int e=c+1; e<espacios;e++){
                                            memoriatotal[d]= linea; }
                                } System.out.println( memoriatotal[c]+" "+c);
                             }//fin cargarProceso
 }//fin class Memoria     
}
}
}


[Ogramar]

Hola no comprendo bien lo que hay que hacer.

Partimos del arreglo memoriatotal [ i ] con índices 0 a 99 y todo relleno de H de modo que tenemos memoriatotal[0]="H", memoriatotal[1]="H", ... memoriatotal[99]="H"

Ahora entro en el programa y me pide Digite Letra del Abecedario: B

Digite la cantidad de veces que se imprimira la Letra: 3

¿Qué es lo que debería hacer el programa?

Creo que a lo mejor falta código, no veo el main. Pega el código de las otras clases que tengas para poder ejecutar lo mismo que tengas tú.

Salu2

[Kadistu]

Gracias Ogramar, Si este es el código que tengo ya completo..con algunas modificaciones del anterior que pegue.

Código: [Seleccionar]

package simuladormemoria2;
import javax.swing.JOptionPane;
/**
  @author Kadistu
 */
public class SimuladorMemoria2 {///main class
   //public class Memoria {
    String [] memoriatotal = new String [100];
    String nombre1="";
    public void inicializarmemoria(){ //con letra H
        for(int i=0;i<100;i++){
            memoriatotal [i] = "H";//
            }
    }//fin inicializarmemoria
    public void cargarLetra() {
       int espacios,n=0;
        String dato="H",numero1;
            nombre1= JOptionPane.showInputDialog("Digite Letra del Abecedario: " );
            String linea = nombre1.toUpperCase();
            if(!linea.equals("H")){
                numero1= JOptionPane.showInputDialog("Digite la cantidad de veces que se imprimira la Letra: " );             
                n= Integer.parseInt(numero1);
                    for(int c=0; c<5;c++){                       
                           espacios=n;
                            if(memoriatotal[c].equals(dato)){
                                for( int d=0; d<espacios;d++){
                                    memoriatotal[d]= linea;
                                     if(!memoriatotal[c].equals(dato))
                                        for( int e=c+1; e<espacios;e++){
                                            memoriatotal[d]= linea; }
                                } System.out.println( memoriatotal[c]+" "+c);
                             }
                    }     
            }
    }//fin cargarLetra()
    public void eliminarLetra(){
       String linea1="";
                nombre1= JOptionPane.showInputDialog("digite la letra que desea eliminar" );
                String linea = nombre1.toUpperCase();
                if(!linea.equals("H")){
                for(int i=0;i<6;i++){                       
                        if (memoriatotal[i].equals(linea))                           
                            linea1 = linea;
                            memoriatotal[i]="H";
                }
                if(linea1.equals(linea))
              JOptionPane.showMessageDialog(null, "se encontro la letra: " + linea1+ " y se borro de la memoria, remplazo H, ","Buscar Letra en Memoria", JOptionPane.INFORMATION_MESSAGE);
               
                else
               JOptionPane.showMessageDialog(null, "No se encontro la letra : " + linea, "Buscar Letra en Memoria", JOptionPane.INFORMATION_MESSAGE);
                }
                else
                JOptionPane.showMessageDialog(null, "No Puede Usar la H" , "Buscar Letra en Memoria", JOptionPane.INFORMATION_MESSAGE);
    }
    public static void main(String[] args) {
        SimuladorMemoria2  m = new SimuladorMemoria2 ();
         m.inicializarmemoria();
      String dec;
      int opcion=0;
    while(true){
            dec=(JOptionPane.showInputDialog(null,
            "+++++++++++++++++++++++++++++++++++++++\n" +
            "                                       \n" +
            "Simulador de Memoria                   \n" +
            "---------------------------------------\n" +
            "1. Incluir Letra                       \n" +
            "2. Eliminar Letra                     \n" +
            "3. Salir                               \n" +       
            "---------------------------------------\n" +
            "Teclea el Número de la Accion a Relizar:\n"+
            "++++++++++++++++++++++++++++++++++++++++"));
            opcion = Integer.parseInt(dec);
           
            switch(opcion){
            case 1: m.cargarLetra();
            break;
            case 2:m.eliminarLetra();
            break;
            case 3:System.exit(0);
            break;
            }
        }   
    }   
}


[Ogramar]

Hola pero no me has respondido a

Partimos del arreglo memoriatotal [ i ] con índices 0 a 99 y todo relleno de H de modo que tenemos memoriatotal[0]="H", memoriatotal[1]="H", ... memoriatotal[99]="H"

Ahora entro en el programa y me pide Digite Letra del Abecedario: B

Digite la cantidad de veces que se imprimira la Letra: 3

¿Qué es lo que debería hacer el programa?

[Kadistu]

Gracias,

Lo que debe hacer el programa es:
Si ingreso una letra del abecedario esta se debe cargar en el arreglo e indicar los espacios de memoria que utilizara representados por el numero “1”:
Ejemplo:
Si digitan letra del abecedario “A” y cantidad “4”.
 
Entonces en el arreglo debe aparecer:
A11110 <-- ocupa espacios del arreglo disponible
H00000
H00000
H00000
Etc.
Ahora si  digitan en otro momento otra letra del abecedario "B" y cantidad "2":
 
Debe aparecer en el arreglo:
A11110
B11000 <--ocupa espacios del arreglo disponible
H00000
Etc.
Luego si deseo eliminar una letra que existe dentro del arreglo, Por ejemplo letra “A”:
 
Debe aparecer en el arreglo:
H00000<-- borra la letra A y remplazarla por H dejando espacio de arreglo disponible en0.
B11000
H00000
Etc.

[Ogramar]

Hola, no sé si lo representas en filas por comodidad, pero dime si lo entiendo bien:

¿El arreglo inicialmente tendrá este contenido?

H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H000

Fíjate que acaba en H000 porque H00000 ocupa 6 espacios, por lo que 16*6 = 96 y para rellenar hasta cien añadiríamos cuatro espacios que son H000

¿Si se digita A y 3, luego M y 4, luego T y 2 debería aparecer esto?:


A11100M11110T11000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H000


¿Digitar A y 3, luego M y 4, luego A y 2 estaría prohibido por repetición de A o estaría permitido?


¿Digitar A y un 7 sería una operación prohibida?

Finalmente, supongamos que tenemos esto:

A11100M11110T11000K10000Y11110G11000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H000

¿Si ahora borramos la M nos quedaría así?

A11100H00000T11000K10000Y11110G11000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H000

Y si ahora introducimos P y 3 nos quedaría así?

A11100P11100T11000K10000Y11110G11000H00000H00000H00000H00000H00000H00000H00000H00000H00000H00000H000


Salu2

[Kadistu]

Gracias  Ogramar,
El planteamiento que propones me parece una alternativa viable por supuesto.

Si,  es correcta la interpretación que haces respeto a la funcionalidad, y cumple con el objetivo del programa en definitiva.
Ahora bien respeto a la cantidad de espacios, 5 espacios estaría bien.
Es decir: H0000H0000H0000H0000H0000……H0000
Esto daría un total de 20 posibilidades. Dado que 20*5=100.
Se establece 4 como valor máximo, más de eso sería una acción prohibida. No hay problema.
El ingreso de letras y borrado que haces es correcta también, así como la cantidad.

Para hacer esto lo que propones seria un arreglo de String
String  [] arreglo = {H0000,H0000,H0000,etc};// hasta completar 100 espacios??

[Ogramar]

Hola, había puesto 6 espacios porque era como lo habías indicado tú, pero se puede hacer con el número de espacios que se quiera.

El punto de partida de este planteamiento, a partir del cual debería irse construyendo el código, sería algo como esto:


Clase PalabraMemoria

Código: [Seleccionar]

public class PalabraMemoria {

    private char[] palabra ;
    public PalabraMemoria() {
        palabra = new char[5];
        palabra[0]='H';
        palabra[1]='0';
        palabra[2]='0';
        palabra[3]='0';
        palabra[4]='0';
    }

    public char getCharAtPosition(int index) {
        return palabra[index];
    }
   
    public char[] getPalabra () {return palabra;}
   
    public String toString() {
        String resultado = "";
        for (int i=0; i<palabra.length;i++) {
            resultado = resultado + palabra[i];
        }
        return resultado;
    }
}

Clase SimuladorMemoria

Código: [Seleccionar]

public class SimuladorMemoria {

    private PalabraMemoria[] memoria;

    public SimuladorMemoria()
    {
        memoria = new PalabraMemoria[20];
        for (int i=0; i<memoria.length; i++) {
            memoria[i] = new PalabraMemoria();
        }
    }

   
   
    public String toString() {
        StringBuilder contenidoMemoria = new StringBuilder();
        for (int i=0; i<memoria.length; i++) {
            contenidoMemoria = contenidoMemoria.append(memoria[i]);
        }
        String resultado = contenidoMemoria.toString();
        return resultado;
    }
}

Clase TestMemoria

Código: [Seleccionar]

public class TestMemoria
{

    public static void main (String[] Args) {
        SimuladorMemoria memoriaSimulada = new SimuladorMemoria();
        System.out.println("El contenido inicial de la memoria es "+ memoriaSimulada.toString());
    }
   
}

Salu2

[Kadistu]

Gracias Ogramar,

En relación al código que posteaste, tengo unas dudas:
La clase PalabraMemoria, como se vincula con las otras clases?
Esta clase PalabraMemoria es donde se puede ingresar una nueva letra utilizando los otros métodos getPalabra(),getCharAtPosition(int index)?
No me queda claro como se podrá ingresar una nueva letra al arreglo,,

[Ogramar]

Hola, PalabraMemoria representa cada una de los componentes de la memoria. A su vez, cada componente de la memoria está compuesto de cinco caracteres (H0000).

La memoria está representada por la clase SimuladorMemoria. La memoria estaría compuesta por 20 palabras, y cada palabra por 5 caracteres, con lo que llegamos al total de 100 caracteres.

Los métodos para manipular la memoria (por ejemplo ingresar una nueva letra al arreglo indicando el número de repeticiones) deberían incluirse en la clase SimuladorMemoria, mientras que los métodos para manipular palabras deberían incluirse en la clase PalabraMemoria.

Este diseño trata de ajustarse a lo que sería un diseño propio de programación orientada a objetos tal y como se explica en el curso Java desde cero: http://aprenderaprogramar.com/index.php?option=com_content&view=category&id=68&Itemid=188

Salu2