Jump to content

procurar em array


TGmarks

Recommended Posts

Caros amigos, estou a tentar fazer um programa que pede ao utilizador para introduzir palavras para um array, depois fazer o mesmo para um segundo array, e no final terá que procurar a penúltima palavra que foi inserida no segundo array e, caso esta exista no primeiro removê-la.

aqui está o código que eu fiz até agora:

import java.util.*;
/**
* Escreva um programa que leia uma série de palavras terminada por “fim” para um array.
Posteriormente, o programa deverá ler mais uma série de palavras terminada por “ok”. O
programa deverá verificar se a palavra inserida imediatamente antes da palavra “ok” existe
no array e se existir deverá removê-la.
*
* @author Tiago
*/
public class fimEok {
   public static void main (String args[]) {
    String[] palavras, palavras2;
    palavras = new String[1000];
    palavras2 = new String[1000];
    System.out.println("Insira uma série de palavras, para terminar inserir fim");
    for (int i = 0; i < 1000; i++){
	    Scanner input = new Scanner (System.in);
	    palavras[i] = input.next();
	    if (palavras[i].equals("fim")){
		    System.out.println("Insira outra série de palavras, para terminar inserir ok");
		    for (int x = 0; x < 1000; x++){
			    palavras2[x] = input.next();
			    if (palavras[x].equals("ok")){ //pára de ler array
				    //código para procurar palavra anterior a "ok" e eliminá-la no 1º array
				    System.out.println(palavras[i]); //imprimir o array sem a palavra removida
			    }

		    }
	    }
    }



   }

}

As minhas dúvidas são:

1º como é que eu vou buscar o penultimo valor? pode-se usar por ex. palavras-1 ??

2º como faço uma procura no array?

3º como se apaga uma entrada no array?

Desde já agradeço qualquer ajuda.

Link to comment
Share on other sites

Deixa-me sugerir que alteres os teus ciclos for por ciclos while. Com esses ciclos vais pedir ao utilizador 1000*1000 palavras e não é isso o pretendido, penso. Com um while podes meter uma segunda condição de paragem, muito mais eficiente neste caso porque evitas os ciclos encadeados.

Quanto as dúvidas:

1º palavras[palavras.length-2];

2º visto que o array não está organizado, terás de o percorrer até encontrares a palavra;

3º num array é díficil... talvez colocar esse elemento a null.

Link to comment
Share on other sites

1º palavras[palavras.length-2];

nop.

se escreveu a palavra fim/ok antes de char a 1000 palavras então a penúltima palavra não é dada pela essa instrução.

é necessário guardar o número de palavras guardadas

3º num array é díficil... talvez colocar esse elemento a null.

colocar a null não +e solução pois irá ficar com um "buraco" no array

é necessário "mover" as palavras para o seu novo local ou ter um terceiro array somente com as palavras aceites

IRC : sim, é algo que ainda existe >> #p@p
Link to comment
Share on other sites

Viva! Ainda não consegui concluir este programa, pois queria implementar um ciclo while no meu programa, mas não sei como o fazer até porque nunca implementei nenhum.

Será que alguém me pode ajudar como é que eu faria para implementar um ciclo while neste caso?

Obg

... a minha ideia seria qualquer coisa como while (palavras.!equals("fim") .... mas o ciclo while não funciona assim pois não?

Link to comment
Share on other sites

o problema não na estrutura do ciclo while, mas na instrução que tens de condição do ciclo:

while ((palavras[i].!equals("fim"))
//                  |
//          este operador está mal
//           é erro de sintaxe
{
}

para resolver o teu problema com um ciclo while, deverias ter em conta que a palavra fim não faz parte do conjunto de palavras.

deverás ler a palavra para um local, confirmar que é válida e se sim, guardar no array correspondente

IRC : sim, é algo que ainda existe >> #p@p
Link to comment
Share on other sites

Um ciclo while é simples de se entender: enquanto algo (variável booleana) não ocorrer, o seu corpo repetir-se-á.

Portanto, o que eu faria era definir uma variável booleana e uma variável de progresso. Iniciar o ciclo, com essa condição E com a condição do i (variável de progresso) ser menor que o tamanho do vector. Se encontrar a palavra fim, a variável booleana toma outro valor (de modo a não reentrar no ciclo). Caso contrário, coloca a palavra no vector e, muito importante, no fim do ciclo incrementar o valor de i.

Só tens de ter atenção se o número de palavras inseridas não vai exceder as 1000 😁

Link to comment
Share on other sites

Fiz o seguinte código:

public class fimEok {
   public static void main (String args[]) {
   boolean fim;
   boolean ok;
   int i = 0;
   int x = 0;
   Scanner input = new Scanner (System.in);
   String[] palavras = new String[1000];
   String[] palavras2 = new String[1000];
   System.out.println("Introduza uma série de palavras. Para terminar introduza 'fim'");
   while (fim=false || i < 1000){
	   palavras[i] = input.next();
	   if (palavras[i].equals("fim")){
		   fim = true;
	   }
	   i++;
   }
   System.out.println("Introduza outra série de palavras. Para terminar introduza 'ok'");
   while (ok=false || x < 1000){
	   palavras2[x] = input.next();
	   if (palavras2[x].equals("ok")){
		   ok = true;
	   }
	   x++;

   }

   }

mas ao introduzir a palavra fim continua sempre a aceitar valores ...

Link to comment
Share on other sites

Exacto, deves inicializar o valor das variáveis a false. Depois no while tens de ter atenção porque ao fazeres = estas a atribuir um valor a essa variável e não a comparar. E tal como tinha dito, a condição do while não é uma condição de paragem, é uma condição de avanço. Ou seja, se o que meteres na condição se verificar então entra no ciclo. Daí o operador a ser usado ser o &&.

Link to comment
Share on other sites

Boas, acho que estou no bom caminho para dar este programa por concluído: tenho um ciclo for para correr o primeiro array e comparar a palavra que coloquei antes da instrução "ok", agora para eliminar a palavra repetida, a solução passa por copiar todo o array excepto a palavra repetida para um novo array. Sei que tenho de usar o método arraycopy, mas não sei como este funciona, muito menos como não passar a palavra pretendida

mais uma vez tenho que agradecer a V/ ajuda

public class fimEok {
   public static void main (String args[]) {
      boolean fim = false;
      boolean ok = false;
      int i = 0;
      int x = 0;
      Scanner input = new Scanner (System.in);
      String[] palavras = new String[1000];
      String[] palavras2 = new String[1000];
      System.out.println("Introduza uma série de palavras. Para terminar introduza 'fim'");
      while (fim == false && i < 1000){
          palavras[i] = input.next();
          if (palavras[i].equals("fim")){
              fim = true;
          }
          i++;
      }
      System.out.println("Introduza outra série de palavras. Para terminar introduza 'ok'");
      while (ok == false && x < 1000){
          palavras2[x] = input.next();
          if (palavras2[x].equals("ok")){
              ok = true;
          }
          x++;

      }
      for (i = 0; i < palavras.length; i++){
          if (palavras2[x-2].equals(palavras[i])){
              System.arraycopy(x, x, input, x, x); //e agora????????
          }
      }


   }
}
Edited by TGmarks
Link to comment
Share on other sites

Aqui tens como usar o método ArrayCopy: http://docs.oracle.com/javase/1.4.2/docs/api/java/lang/System.html#arraycopy(java.lang.Object, int, java.lang.Object, int, int).

Rapidamente, System.arraycopy(arrayFrom, indiceNoArrayFrom, ArrayTo, indiceNoArrayTo, numElementosCopiados). Em que arrayFrom é o array inicial, indiceNoArrayFrom é a posição a partir do qual queres copiar, ArrayTo é o array para onde queres copiar, indiceNoArrayTo a posição a partir da qual vais começar a escrever, e numElementosCopiados é o número de elementos que vão ser copiados.

Dentro do if, para encontrares a palavra anterior a palavra "ok" no array deveria ser palavras2[palavras2.length-2].

Link to comment
Share on other sites

Sim, tens razão desculpa.

Podes tentar isto:

int[] newArray = new int[i]; //e i porque incrementas sempre o i, mesmo depois de ter chegado o fim
System.arraycopy(palavras1, 0, newArray, 0, posDaPalavra );
System.arraycopy(original, posDaPalavra+1, newArray, posDaPalavra, i - posDaPalavra);
return n;
Edited by Jabba
Link to comment
Share on other sites

código para remover todas as palavras do segundo array do primeiro array

import java.util.*;

/**
* Escreva um programa que leia uma série de palavras terminada por “fim” para
* um array. Posteriormente, o programa deverá ler mais uma série de palavras
* terminada por “ok”. O programa deverá verificar se a palavra inserida
* imediatamente antes da palavra “ok” existe no array e se existir deverá
* removê-la.
*/
public class WordSearch
{
protected static final int ARRAY_SIZE = 1000;
protected static final String FIRST_LIMIT = "fim";
protected static final String SECOND_LIMIT = "ok";

public static void main(String args[])
{
	Scanner sc = new Scanner(System.in);
	String word = "";

	System.out.println("Insira os elementos da primeira lista ('fim' para terminar) : ");
	String first[] = new String[ARRAY_SIZE];
	int first_size = 0;
	while (first_size != ARRAY_SIZE && !word.equals(FIRST_LIMIT))
	{
		word = sc.next();
		if (!word.equals(FIRST_LIMIT))
		{
			first[first_size] = word;
			first_size++;
		}
	}
	first = Arrays.copyOf(first, first_size);

	System.out.println("Insira os elementos da segunda lista ('ok' para terminar) : ");
	String second[] = new String[ARRAY_SIZE];
	int second_size = 0;
	while (second_size != ARRAY_SIZE && !word.equals(SECOND_LIMIT))
	{
		word = sc.next();
		if (!word.equals(SECOND_LIMIT))
		{
			second[second_size] = word;
			second_size++;
		}
	}
	second = Arrays.copyOf(second, second_size);

	Arrays.sort(second, new Comparator()
	{
		public int compare(Object s1, Object s2)
		{
			return ((String) s1).compareTo((String) s2);
		}
	});

	/* SOLUÇÃO SEM ARRAYCOPY */
	String result[] = new String[first.length];
	int result_size = 0;
	for (int i = 0; i < first.length; i++)
	{
		if (Arrays.binarySearch(second, first[i]) < 0)
		{
			result[result_size] = first[i];
			result_size++;
		}
	}
	result = Arrays.copyOf(result, result_size);

	System.out.println("Elementos não eliminados (SEM ARRAY COPY): ");
	for (int i = 0; i < result.length; i++)
	{
		System.out.print(result[i] + " ");
	}
	System.out.println("");

	/* SOLUÇÃO COM ARRAYCOPY */
	for (int i = 0; i < first.length; i++)
	{
		if (Arrays.binarySearch(second, first[i]) >= 0)
		{
			if (i < first.length - 2)
			{
				System.arraycopy(first, i + 1, first, i, first.length - i - 2);
			}
			first = Arrays.copyOf(first, first.length - 2);
		}
	}

	System.out.println("Elementos não eliminados (SEM ARRAY COPY): ");
	for (int i = 0; i < first.length; i++)
	{
		System.out.print(first[i] + " ");
	}
	System.out.println("");
}
}
IRC : sim, é algo que ainda existe >> #p@p
Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
×
×
  • Create New...

Important Information

By using this site you accept our Terms of Use and Privacy Policy. We have placed cookies on your device to help make this website better. You can adjust your cookie settings, otherwise we'll assume you're okay to continue.