Mensajes

Hola buenas noches , tengo una duda sobre hacer el metodo push para una pila y el remove. Esque tengo que hacer una pila con listas enlazadas y mi pila es una pila limitada es decir que tiene una capacidad asignada y cuando se llena la pila el ultimo elemento se elimina y se inserta el elemento siguiente que quieres meter en la cabeza . Bien mi duda esta en como eliminar el ultimo elemento no se como hacerlo tengo este codigo :

public void push(T element) {
LinkedStackNode<T> temp = new LinkedStackNode<T>(element);
if (isFull()) {
remove();
temp.setNext(this.top);

this.top = temp;

} else if(this.first==null){

this.first = temp;
this.top = temp;
}else{
temp.setNext(this.top);
this.top = temp;
}
this.count++;
}// push

public void remove (){
if(this.first!=null){
this.first = this.top.getNext();
this.count--;
}
No se que pasa pero no me elimina el ultimo nodo.
¿Alguien me puede ayudar? Espero recibir una buena respuesta.

No quiero que me hagan la tarea simplemente quiero que me den una idea para hacer el metodo push con una estructura enlazada como hacer que el elemento que mas tiempo lleve se sustituya por el elemento que quieres meter al tener la pila llena nada mas. No estoy pidiendo nada del otro mundo simplmente una idea.

No puedo usar esa clase la estructura enlazada tiene que estar echa por mi no puedo usar nada de la api

Hola buenas tardes tengo una duda con la estructura de datos de pila. Me han pedido hacer un ejercicio que es implementar una pila con estructura enlazada pero no es una pila normal sino una pila limitada es decir que tiene capacidad maxima pero con una pecularidad que la operacion push que es apilar sufre una modificacion que si por ejemplo la pila esta llena es decir alcanza su maxima capacidad al introducir un elemento se deber eliminar el elemento que mas tiempo lleva en la pila es decir tengo una pila tal que asi: 1 2 3 4 su capacidad es 4 y si quieres meter el elemento 5 se deberia cambiar el 1 por el 5 quedando una la estructura asi 5 2 3 4 si quieres meter otro elemento se quitaria el 2 porque es el elemento que mas tiempo lleva en la pila y asi sucesivamente pero eso hacerlo con una estructura enlazada y que su complejidad sea constante. Alguien me puede ayudar? Espero que haya una buena respuesta

Hola buenas tardes me gustaría saber si cuando cambias la pantalla de un portátil tiene que ser idéntica al modelo que quieres cambiar. Es que tengo un portatil acer que se me ha roto la pantalla el modelo de mi pantalla es ASP.E1. 571 -32326G5 y estoy buscando por internet donde encontrarla pero lo maximo que encuentro es un pantalla Acer Aspire E1-571-53214G50MNKS es la mas barata me gustaria saber si funcionaría en mi portatil ya que ambas son de 15,6 pulgadas y la marca es ASP E1. Espero una respuesta buena . Gracias

Hola buenas noches me gustaría saber si cuando cambias la pantalla de un portátil tiene que ser idéntica al modelo que quieres cambiar. Es que tengo un portatil acer que se me ha roto la pantalla el modelo de mi pantalla es ASP.E1. 571 -32326G5 y estoy buscando por internet donde encontrarla pero lo maximo que encuentro es un pantalla ASP.E1 571 6454 es la mas barata me gustaria saber si funcionaría en mi portatil ya que ambas son de 15,6 pulgadas y la marca es ASP E1. Espero una respuesta buena . Gracias

Hola buenas tardes a ver tengo una duda sobre un ejercicio : El ejercicio consiste en formar palabras de tamaño mayores o iguales que 3 con la condicion de que se sean palindromas. Es decir tu tienes un tablero de nxn caracteres y tienes que formar palabras con esa condicion y sin que se pueda usar la misma casilla en la palabra. Tengo el codigo casi echo pero no se como hacer lo de que no se use la misma casilla dos veces alguien me puede ayudar?
El codigo es este :
public class Crossword {
   //Atributes
   
   private ArrayList<String> list;
   private char[][] panel;
   private int size;
   
   //Constructor
   public Crossword(int size , char[][] panel){
      this.size=size;
      this.panel=panel;
      this.list = new ArrayList<String>();
   }
   //Class anonima
   public Comparator<String> lexicographically = new Comparator<String>(){
                public int compare(String o1, String o2) {
                  if (o1.length() > o2.length()) {
                     return 1;
                        } else
                              if (o1.length() < o2.length()) {
                                 return -1;
                              }
                  return o1.toString().compareToIgnoreCase(o2.toString());
               }  //Compare
          };//Comparator
   public void buildWords(int i, int j, int direction, String words){
      int next_i=0; int next_j=0;
      switch (direction) {
                   case 1: // Up         
                      next_i = i - 1;
                      next_j = j;
                      break;
                   case 2: // Diagonal up right
                      next_i = i - 1;
                      next_j = j + 1;
                      break;
                     case 3: // Right
                        next_i = i;
                        next_j = j + 1;
                      break;
                   case 4: // Diagonal down right
                      next_i = i + 1;
                      next_j = j + 1;
                      break;
                   case 5: // Down
                      next_i = i + 1;
                      next_j = j;
                      break;
                     case 6: // Diagonal down left
                       next_i = i + 1;
                      next_j = j - 1;
                      break;
                   case 7: // Left
                      next_i = i;
                      next_j = j - 1;
                      break;
                   case 8: // Diagonal up left
                      next_i = i - 1;
                      next_j = j - 1;
                      break;
                }//switch
      if ((next_i >= 0 && next_i < this.size) &&
            (next_j >= 0 && next_j < this.size) ) {
                
            words = words + this.panel[j];
            System.out.println(words);
               }
                                 
                  if (words.length() >= 3) {
                     int contador =0; String aux = "";
                     for(int h = words.length()-1; h>=0; h--){
                        aux = aux + words.charAt(h);
                     }
                     for(int l=0 ; l<=aux.length()-1 ; l++){
                        if(aux . charAt(j) == words.charAt(j)){
                           contador++;
                        }
                     }
                     if(!this.list.contains(words) && contador == words.length()){
                        
                           this.list.add(words);
                     }
           }
   }
   public static void main(String[] args) {
      Scanner scan = new Scanner(System.in);
      //Declaracion de variables      
      //Test indica el numero de test.
      //Size indica la longitud del tablero
      //Chart es una matriz de caracteres
      //Words es un vector de la clase Crossword
      //Text almacena la cadena de caracteres introducida por consola
      int test; int size;  char[][] chart; Crossword[] words;
      ArrayList<String> words2;
      String text;
      //Leo los test que se quieren pasar
      System.out.println("Numero de test: ");
      test = scan.nextInt();
      
      words = new Crossword[test];
      int n=0;
      while(n<test){         
          System.out.println("Tamaño de tabla: ");         
          size = scan.nextInt();
            chart = new char[size][size];
                  for(int i = 0; i < chart.length; i++){
                     
                       text = scan.next();
         
                      for(int j = 0; j < text.length(); j++){
                         /**
                         * char charAt(int index)
                              * Devuelve el carácter indicado
                              * como índice. El primer carácter de la cadena será
                              * el del índice 0. Junto con el método .length() podemos
                              * recuperar todos los caracteres de la cadena de texto.
                         */
                            chart[j] = text.charAt(j);
               }//for interno                  
            }//for externo 1
                  if(test-1==n){
                     words[n]=new Crossword(size,chart);
                     for (int i = 0; i < size; i++){
                                    for (int j = 0; j < size; j++){
                                        // Las 8 direcciones de cada elemento
                                        for (int d = 1; d <= 8; d++){
                                           words[n].buildWords(i, j, d, "");                  
                                  }
                              }
                     }                                 
                  }else{
                     words[n]=new Crossword(size,chart);
                     for (int i = 0; i < size; i++){
                                    for (int j = 0; j < size; j++){
                                        // Las 8 direcciones de cada elemento
                                        for (int d = 1; d <= 8; d++){
                                           words[n].buildWords(i, j, d, "");                  
                                  }//for
                              }//for
                     }//for
                  }//else
               n++;
       }//while
      scan.close();
      words2 = new ArrayList<String>();
      int i =0;
      while ( i<words.length){
         words2 = words.getList();
         if(words.length-1==i){
            for(String word : words2){
               if(!word.isEmpty()){
                  System.out.println(word);
               }//if
            }//for each            
         }//if
         else{
            if(words.length-1!=i){
               for(String word : words2){
                  if(!word.isEmpty()){
                     System.out.println(word);
                  }//if
               }//for each
                System.out.println("");
            }//if
         }//else
         i++;
      }//while
   }//Main
   public ArrayList<String> getList() {
      int i=0;
      while ( i < this.list.size())
      Collections.sort(this.list, lexicographically);
      i++;
      return list;
   }//getList   
}//Crossword

Podeis cerrar el tema ya esta resuelto

Tema cerrado

Alguien me puede ayudar con la parte de interfaz gráfica de usuario de este ejercicio. Es que no se como hacer lo de cargar un fichero y mostrar el tablero que pide. Saludos !



Palabras Cruzadas.

En el pasatiempo de palabras cruzadas, se dispone de una tabla de letras minúsculas NxN y el objetivo es encontrar palabras.  Una palabra puede empezar en cualquier lugar en la tabla y puede ser construida utilizando letras adyacentes tanto en forma horizontal, vertical o diagonal.

Un ejemplo de una tabla 4x4 puede ser:

anap
siix
aopp
sxxx
Algunas de las palabras que aparecen son:

asas
ana
pios
Se pide construir un programa que permita tanto resolver manualmente un pasatiempo de palabras cruzadas como de forma automática. Las palabras que se buscarán no serán palabras de un diccionario sino simplemente palabras formadas por caracteres que estén en secuencia creciente respecto a su codificación en ASCII. El programa tendrá dos interfaces, uno a través de la entrada/salida estándar y el otro mediante un interfaz gráfico de usuario.

Interfaz entrada/salida estándar

Este será el interfaz por defecto y será llamado desde el método main de una clase Main del programa. No podrá haber ningún otro método main en ninguna otra clase. El objetivo del programa a través de este interfaz es resolver automáticamente un pasatiempo de palabras cruzadas como el descrito, encontrando todas las palabras diferentes válidas. Una palabra es válida si tiene de 3 a N2 letras todas ellas en orden estrictamente ascendente respecto a su codificación ASCII. Por ejemplo, "abc" es una palabra válida, "abcc" no y tampoco es legal "robar". Se debe tener en cuenta la eficiencia de la solución encontrada.

Entrada

La primera línea contendrá un número indicando el número de casos de test que siguen. A continuación irá una línea en blanco y también habrá una línea en blanco separando cada caso de test. Cada test contendrá un primer número N en una línea indicando el tamaño de la tabla. N podrá valer como mucho 20. Esa línea irá seguida de N líneas cada una de ellas con una cadena de N letras.

Salida

Para cada test la salida debe ser como se describe a continuación e ir separada con una línea en blanco, excluido el último caso de test. La salida de cada test estará formada por una lista de palabras únicas ordenadas de acuerdo a los siguientes criterios:

1. Las palabras más cortas van antes que las palabras más largas

2. Las palabras de igual longitud se ordenan lexicográficamente por su valor ASCII.

No se deben añadir blancos ni líneas extras. Si no hay palabras, no se imprimirá nada para ese test.

Ejemplo

Entrada

2

3

uno

dos

ves

4

abcd

bcda

cdab

dabc



Salida

deo
des
dev
dno
dns
dnu
dos
dou
dov
eos
eou
eov
nos
nou
nov
deos
deou
deov
dnos
dnou
dnov
abc
abd
acd
bcd
abcd


Interfaz gráfico de usuario

El interfaz gráfico de usuario se podrá arrancar a partir de la llamada a un método público estático denominado void interfazGrafico() que no tomará ningún argumento

y no devolverá tampoco ningún valor.

A través del interfaz gráfico de usuario  el programa deberá poder cubrir los siguientes requerimientos:

Cargar un pasatiempo desde un fichero y visualizarlo en pantalla mediante una tabla de NxN casillas. El formato de un fichero que contiene un pasatiempo será un fichero de texto que contendrá un único test de la forma descrita en la entrada de la interfaz gráfico de usuario y que podrá contener una solución parcial al pasatiempo. Por tanto contendrá una primera línea con el tamaño N del pasatiempo y a continuación N líneas con una string en cada una de N caracteres que definirá la tabla de caracteres. Después podrá venir una lista de palabras, que puede ser vacía, contenidas en la tabla. Si la lista de palabras solución es no vacía, se separará con una línea en blanco de la parte de definición del pasatiempo. La lista será un conjunto de líneas conteniendo una palabra en cada una de ellas que pertenece al conjunto solución del problema. Las palabras de la solución deberán ir ordenadas cómo se describe en la salida del interfaz  estándar. Al cargar un pasatiempo se visualizará tal como se indica en el punto 3 junto con las palabras solución que contenga el fichero resaltándolas adecuadamente.
Salvar un pasatiempo en cualquier momento a un fichero en el formato descrito en 1.
Visualizar el pasatiempo consistirá en mostrar en pantalla la tabla de caracteres que definen el pasatiempo y de resaltar de algún modo las palabras solución encontradas hasta el momento. Si al cargar un pasatiempo, éste contiene palabras de la solución deberá resaltarlas en la tabla de algún modo.
Permitir al usuario resolver el pasatiempo, mediante la selección de las letras que forman una palabra. El usuario podrá validar el conjunto de letras seleccionado como una palabra oprimiendo un botón. Si es una palabra válida, la palabra irá a formar parte  de una lista de palabras solución que serán visualizadas en pantalla de forma continúa. Si el conjunto de letras no forma una palabra válida, se eliminará la selección realizada por el usuario.
Ayudar al usuario resolviendo automáticamente el pasatiempo a petición suya, visualizando adecuadamente dicha solución.