[RESOLVIDO] Codificação e Decodificação

[color=blue][b]Ola amigos,

Sou novo aqui no fórum e estou precisando de um help.
Estou tentando fazer um programa que faça codificação e decodificação de alguma palavra digitada pelo usuário.
Segue abaixo a explicação para vcs entenderem melhor.[/b][/color]

[i]Uma das formas mais importantes de se preservar a segurança dos dados em computadores é a criptografia.
Na criptografia por substituição, o alfabeto normal é trocado por outro, com as letras fora de ordem. Na
codificação da mensagem, cada caracter é trocado pelo seu correspondente no novo alfabeto; na decodificação
é feito o processo inverso. Escreva um programa com as seguintes especificações:

(a) Ler um inteiro indicando o tipo de operação: 1 para codificar e 2 para
decodificar.
(b) Ler uma string (com espaços) a ser codificada/decodificada.
© Codificar/decodificar a mensagem lida segundo a tabela abaixo.
(d) Imprimir a mensagem resultante.

Alfabeto Normal:
a b c d e f g h i j k l m n o p q r s t u v w x y z

Novo Alfabeto:
p x v r b t y j m z c i s w l a f u d n h o g q e k[/i]

[color=blue][b]Eu tentei fazer alguma coisa pra pelo menos modificar o alfabeto, me disseram que não foi uma boa idéia fazer assim,
mas foi o unico jeito que arrumei. Me disseram para tentar usar um Hashtable, mas nao faço idéia de como fazer.

Segue abaixo meu código. Será que alguem consegue me ajudar com isso? Já to quebrando a cabeça a uma semana e nada…
[/b][/color]

[code]import java.util.Scanner;

public class Lista{
public static void main(String args []){

	Scanner Leitor = new Scanner(System.in);
	String Word, Trade;    	
	System.out.print("Digite uma frase ou palavra: ");
	Word = Leitor.nextLine();
	System.out.println();
	System.out.println("Sua palavra foi codificada.\n");
	    	
	Trade = Word.replace("a", "p");
	Word = Trade;
	Trade = Word.replace("b", "x");
	Word = Trade;
	Trade = Word.replace("c", "v");
	Word = Trade;
	Trade = Word.replace("d", "r");
	Word = Trade;
	Trade = Word.replace("e", "b");
	Word = Trade;
	Trade = Word.replace("f", "t");
	Word = Trade;
	Trade = Word.replace("g", "y");
	Word = Trade;
	Trade = Word.replace("h", "j");
	Word = Trade;
	Trade = Word.replace("i", "m");
	Word = Trade;
	Trade = Word.replace("j", "z");
	Word = Trade;
	Trade = Word.replace("k", "c");
	Word = Trade;
	Trade = Word.replace("l", "i");
	Word = Trade;
	Trade = Word.replace("m", "s");
	Word = Trade;
	Trade = Word.replace("n", "w");
	Word = Trade;
	Trade = Word.replace("o", " ");
	Word = Trade;
	Trade = Word.replace("p", "l");
	Word = Trade;
	Trade = Word.replace("q", "a");
	Word = Trade;
	Trade = Word.replace("r", "f");
	Word = Trade;
	Trade = Word.replace("s", "u");
	Word = Trade;
	Trade = Word.replace("t", "d");
	Word = Trade;
	Trade = Word.replace("u", "n");
	Word = Trade;
	Trade = Word.replace("v", "h");
	Word = Trade;
	Trade = Word.replace("w", "o");
	Word = Trade;
	Trade = Word.replace("x", "g");
	Word = Trade;
	Trade = Word.replace("y", "q");
	Word = Trade;
	Trade = Word.replace("z", "e");
	Word = Trade;
	Trade = Word.replace(" ", "k");
	
	System.out.println("Veja como ficou a codificação de sua palavra: "+Trade+"\n");
}

}[/code]

Olá ,

Acho que isso é que voce quer:

import java.util.Map;
import java.util.Scanner;

public final class Cryptor {

	private static String uncodifiedWord;
	private static StringBuffer codifiedWord = new StringBuffer();
	
	public static void main(String[] args) {
		
		Alphabet alphabet = new Alphabet();
        Scanner leitor = new Scanner(System.in);  
               
        System.out.print("Digite uma frase ou palavra: ");  
        uncodifiedWord = leitor.nextLine();  
        
        for (int i = 0; i < uncodifiedWord.length(); i++) {
			
        	// pega a primeira letra da String digitada
        	Character letterUncodifiedWordd = uncodifiedWord.charAt(i);
        	
        	for (Map.Entry<Character,Character> map : alphabet.getAlphabet().entrySet()) {
				if(map.getKey().equals(letterUncodifiedWordd)){
					codifiedWord.append(map.getValue());
				}
			}
		}
        
        System.out.println("Sua palavra codificada : " + codifiedWord.toString() );
        
	}	
}

Classe que representa o alfabeto

import java.util.HashMap;
import java.util.Map;

public class Alphabet  {
	
	private final Map<Character,Character> alphabet;

	public Alphabet() {

		alphabet = new HashMap<Character,Character>();
		alphabet.put('a', 'p');
		alphabet.put('b', 'x');
		alphabet.put('c', 'v');
		alphabet.put('d', 'r');
		alphabet.put('e', 'b');
		alphabet.put('f', 't');
		alphabet.put('g', 'y');
		alphabet.put('h', 'j');
		alphabet.put('i', 'm');
		alphabet.put('j', 'z');
		alphabet.put('k', 'c');
		alphabet.put('l', 'i');
		alphabet.put('m', 's');
		alphabet.put('n', 'w');
		alphabet.put('o', ' ');
		alphabet.put('p', 'l');
		alphabet.put('q', 'a');
		alphabet.put('r', 'f');
		alphabet.put('s', 'u');
		alphabet.put('t', 'd');
		alphabet.put('u', 'n');
		alphabet.put('v', 'h');
		alphabet.put('w', 'o');
		alphabet.put('x', 'g');
		alphabet.put('y', 'q');
		alphabet.put('z', 'e');
		alphabet.put(' ', 'k');

	}
	
	@Override
	public String toString() {
		return "Alphabet";
	}
	
	public Map<Character, Character> getAlphabet() {
		return alphabet;
	}
	
}

Abraços.

Obrigado Daniel,

Seria isso sim o que eu queria, porém está faltando uma coisa.
Preciso que seja feito um looping para que a palavra codificada seja decodificada novamente.

Por exemplo, vc digita a palavra, ela será codificada, entao depois disso o programa nao deve finalizar, e sim dar a opção
para o usuário escolher para decodificar apertando a tecla 2 no teclado, e depois que tiver sido decodificado, se o usuário
apertar a tecla 1 no teclado, a palavra codifica novamente, e se digitar 0, ai sim sai do programa.

Segue ai abaixo alguma coisa que eu fiz, continuando o código que eu mesmo fiz mais acima:

[code]import java.util.Scanner;

public class Teste{

public static void main(String args []){  
    int codigo = -1;  
    String Word;	
        System.out.println("1 - Codificar");  
        System.out.println("2 - Decodificar");  
        System.out.println("0 - Sair");              
        Scanner Leitor = new Scanner (System.in);  
		codigo = Leitor.nextInt(); 
		
	
	if (codigo == 1){
		executeAction(codigo);
	}
	else if (codigo == 2){
		executeAction(codigo);
	}
}              
  
public static void executeAction(int codigo){  
    switch (codigo){  
        case 1:  
        Scanner Leitor = new Scanner(System.in);
    	String Word, Trade;    	
    	System.out.print("Digite uma frase ou palavra: ");
    	Word = Leitor.nextLine();
    	System.out.println();
    	System.out.println("Sua palavra foi codificada.\n");
    	    	
    	Trade = Word.replace("a", "p");
    	Word = Trade;
    	Trade = Word.replace("b", "x");
    	Word = Trade;
    	Trade = Word.replace("c", "v");
    	Word = Trade;
    	Trade = Word.replace("d", "r");
    	Word = Trade;
    	Trade = Word.replace("e", "b");
    	Word = Trade;
    	Trade = Word.replace("f", "t");
    	Word = Trade;
    	Trade = Word.replace("g", "y");
    	Word = Trade;
    	Trade = Word.replace("h", "j");
    	Word = Trade;
    	Trade = Word.replace("i", "m");
    	Word = Trade;
    	Trade = Word.replace("j", "z");
    	Word = Trade;
    	Trade = Word.replace("k", "c");
    	Word = Trade;
    	Trade = Word.replace("l", "i");
    	Word = Trade;
    	Trade = Word.replace("m", "s");
    	Word = Trade;
    	Trade = Word.replace("n", "w");
    	Word = Trade;
    	Trade = Word.replace("o", " ");
    	Word = Trade;
    	Trade = Word.replace("p", "l");
    	Word = Trade;
    	Trade = Word.replace("q", "a");
    	Word = Trade;
    	Trade = Word.replace("r", "f");
    	Word = Trade;
    	Trade = Word.replace("s", "u");
    	Word = Trade;
    	Trade = Word.replace("t", "d");
    	Word = Trade;
    	Trade = Word.replace("u", "n");
    	Word = Trade;
    	Trade = Word.replace("v", "h");
    	Word = Trade;
    	Trade = Word.replace("w", "o");
    	Word = Trade;
    	Trade = Word.replace("x", "g");
    	Word = Trade;
    	Trade = Word.replace("y", "q");
    	Word = Trade;
    	Trade = Word.replace("z", "e");
    	Word = Trade;
    	Trade = Word.replace(" ", "k");
	
		System.out.println("Veja como ficou a codificação de sua palavra: "+Trade+"\n");
		break;  
			
        case 2:
        
        System.out.println("A palavra era "+*);  
    break;  
	}           
}

}[/code]

Fiz isso usando um switch, case 1 e case 2…
no case 1 ele codifica, e no case 2 deveria decodificar… Mas nao estou conseguindo fazer o case 2 funcionar.
Na minha visao, o que deve ser colocado no lugar do * no case 2 seria a palavra digitada novamente, mas nao está dando certo.

Será que estou fazendo certo?

Ok, farei a lição de casa completa então :slight_smile:

Segue o código :

import java.util.Map;
import java.util.Scanner;

public final class Cryptor {
	
	private final Alphabet alphabet;
	private String enteredWord;
	
	public Cryptor() {
		alphabet = new Alphabet();
	}

	public int init() {
		Scanner leitor = new Scanner(System.in);

		System.out.print("Digite uma frase ou palavra: ");
		enteredWord = leitor.nextLine();

		System.out.println("1 - Codificar");
		System.out.println("2 - Decodificar");
		System.out.println("0 - Sair");
		System.out.println("\n");
		int result = Integer.parseInt(leitor.nextLine());
		
		return result;
	}

	public static void main(String[] args) {

		Cryptor cryptor = new Cryptor();

		int option = 0;

		do {
			option = cryptor.init();
			switch (option) {
				case 1:
					cryptor.codifyEnteredWord();
					break;
				case 2:
					cryptor.uncodifyEnteredWord();
					break;
				case 0 :
					System.exit(0);
			}

		} while (option != 0);

	}

	public void codifyEnteredWord() {
		
	    StringBuffer codifiedWord = new StringBuffer();
	    
		System.out.println("Codificando palavra..");

		for (int i = 0; i < enteredWord.length(); i++) {

			for (Map.Entry<Character, Character> map : getAlphabet().getAlphabet().entrySet()) {
				if (map.getKey().equals(enteredWord.charAt(i))) {
					codifiedWord.append(map.getValue());
				}
			}
		}

		System.out.println("Palavra codificada : " + codifiedWord.toString());
	}


	public void uncodifyEnteredWord() {
		
		StringBuffer uncodifiedWord = new StringBuffer();
		
		System.out.println("Uncodifying word...");

		for (int i = 0; i < enteredWord.length(); i++) {

			for (Map.Entry<Character, Character> map : getAlphabet().getAlphabet().entrySet()) {
				if (map.getValue().equals(enteredWord.charAt(i))) {
					uncodifiedWord.append(map.getKey());
				}
			}
		}
		
		System.out.println("Palavra descodificada : " + uncodifiedWord.toString());

	}

	public Alphabet getAlphabet() {
		return alphabet;
	}

}

[code]
import java.util.HashMap;
import java.util.Map;

public class Alphabet {

private final Map<Character,Character> alphabet;

public Alphabet() {

	alphabet = new HashMap<Character,Character>();
	alphabet.put('a', 'p');
	alphabet.put('b', 'x');
	alphabet.put('c', 'v');
	alphabet.put('d', 'r');
	alphabet.put('e', 'b');
	alphabet.put('f', 't');
	alphabet.put('g', 'y');
	alphabet.put('h', 'j');
	alphabet.put('i', 'm');
	alphabet.put('j', 'z');
	alphabet.put('k', 'c');
	alphabet.put('l', 'i');
	alphabet.put('m', 's');
	alphabet.put('n', 'w');
	alphabet.put('o', ' ');
	alphabet.put('p', 'l');
	alphabet.put('q', 'a');
	alphabet.put('r', 'f');
	alphabet.put('s', 'u');
	alphabet.put('t', 'd');
	alphabet.put('u', 'n');
	alphabet.put('v', 'h');
	alphabet.put('w', 'o');
	alphabet.put('x', 'g');
	alphabet.put('y', 'q');
	alphabet.put('z', 'e');
	alphabet.put(' ', 'k');

}

@Override
public String toString() {
	return "Alphabet";
}

public Map<Character, Character> getAlphabet() {
	return alphabet;
}

}
[/code]Abraços.

1 curtida

Oláá Galera,

Finalmente consegui resolver esse código.
Obrigado pela ajuda Danie, mas eu fiz diferente do que vc postou.

Segue abaixo o código rodando corretamente e sem erros.

Qualquer dúvida futura estarei aqui denovo, muito util mesmo!

Abraços a todos.

[code]import java.util.Scanner;

public class Criptador{
public static void main(String args []){

	String Codified = "";
	System.out.print("Digite uma palavra: ");
	String Word = Start();
	System.out.println("O que voce gostaria de fazer?"); 
	int Option = -1;
	
	do{ //Looping para usar a mesma palavra usada na codificacao para decodificacao  
		Option = Option();
		if (Option == 1){  
			Codified = codificarPalDig(Word);  
		} //Fim if		
		else if (Option == 2){  
			Word = decodificarPalDig(Codified); 
		} //Fim else if
		else
			System.exit(0);  
	} //Fim do
	while (Option != 0);
} //Fim main
    	 		
public static int Option(){ //Funcao para escolher a opcao de Codificar/Decodificar
	System.out.println("1 - Codificar");  
    System.out.println("2 - Decodificar");  
    System.out.println("0 - Sair");  	
    System.out.println();  
    Scanner Leitor = new Scanner(System.in);
	int Option = Leitor.nextInt();
return Option;
}	
	
public static String Start(){ //Funcao para digitar a palavra ou frase a ser codificada/decodificada  
    Scanner Leitor = new Scanner(System.in);  
    String Word = Leitor.nextLine();  
    System.out.println(); 
return Word;	
}

public static String codificarPalDig(String x){ //Funcao para codificacao da palavra  
   
   	System.out.println("Codificando a palavra...");
   	
	String AlfNorm = "abcdefghijklmnopqrstuvxwyz ";
	String NewAlf = "pxvrbtyjmzcisw lafudnhogqek";
	char temp[] = new char [x.length()];
	
	for (int i = 0; i < x.length(); i++){ //Percorre a palavra digitada
		temp[i] = x.charAt(i); //Quebra a string em char e armazena as letras em temp
	}
	for (int j = 0; j < x.length(); j++){ //Percorre a palavra digitada
		for (int k = 0; k < AlfNorm.length(); k++){ //Percorre o Alfabeto Normal
			if (x.charAt(j) == AlfNorm.charAt(k)){ //Verifica se as letras da palavra digitada sao iguais as do alfabeto normal
				temp[j] = NewAlf.charAt(k); //Se sim, temp [j](letras da palavra) recebe novo alfabeto quebrado na ordem que estavam no alfabeto normal.
			}
		}
	}
	String NeWord = new String(temp);
	System.out.println("Palavra codificada: "+NeWord+"\n");
return NeWord;	
} //Fim da funcao Codificar

public static String decodificarPalDig(String x){ //Funcao para decodificacao
	
	System.out.println("Decodificando a palavra...");
   	
	String AlfNorm = "abcdefghijklmnopqrstuvxwyz ";
	String NewAlf = "pxvrbtyjmzcisw lafudnhogqek";
	char temp[] = new char [x.length()];
	
	for (int i = 0; i < x.length(); i++){ //Percorre a palavra digitada
		temp[i] = x.charAt(i);//Quebra a string em char e armazena as letras em temp
	}
	for (int j = 0; j < x.length(); j++){ //Percorre a palavra digitada
		for (int k = 0; k < NewAlf.length(); k++){ //Percorre o novo alfabeto
			if (x.charAt(j) == NewAlf.charAt(k)){ //Verifica se as letras da palavra digitada sao iguais as do novo alfabeto
				temp[j] = AlfNorm.charAt(k); //Se sim, temp [j](letras da palavra) recebe o alfabeto quebrado na ordem que estavam no novo alfabeto
			}
		}
	}
	String NeWord = new String(temp);
	System.out.println("Palavra decodificada: "+NeWord+"\n");
return NeWord;	
} //Fim da funcao decodificar        

} //Fim da Classe[/code]