Ta aí uma coisa que nao consigo imaginar…
usando if, if…else, e/ou while:
Deitel:
4.30 (Palíndromos) Um palíndromo é uma seqüencia de caracteres que é lida da esquerda para a direita, ou da direita para esquerda. Por exemplo, cada um dos seguinter inteiros de cinco dígitos é um palíndromo: 12321, 55555, 45554, 11611. Escreva um aplicativo que leia em um inteiro de cinco de dígitos e determine se ele é ou não um palíndromo. Se o número não for de cinco dígitos, esxiba uma mensagem de erro e permita que o usuário insira um novo valor.
A grande dúvida é… qual a condição que validaria um políndromo??? Precisaria ler caractere por caractere? se sim, como se faz? se não, como???
O caractere da posição i deve ser igual ao da posição length - i, para todo i.
Pense um pouco e tente fazer com essa idéia antes de ver o código pronto
public class Palindrome {
public static void main(String[] args) {
int i = 0;
while (i < args[0].length()) {
if (args[0].charAt(i) != args[0].charAt(args[0].length() - i -1)) {
System.out.println("Nao eh palindrome.");
System.exit(0);
}
i++;
}
System.out.println("Eh palindrome");
}
}
Uma outra idéia, se o seu professor não quiser que você use recursos prontos, ou se você quiser conhecer outras possibilidades…
Use uma estrutura de dados do tipo PILHA (LIFO - last in first out). Você pode usar algo pronto ou criar um objeto pilha que utiliza um vetor de cinco posições e tem os métodos push() (inserir) e pop() (remover).
Vá pegando cada caractere do String (do 1º ao último) e inserindo um por um na pilha.
Depois crie uma segunda String (o ideal seria um StringBuffer, mas eu sugiro String pra usar o mínimo de recursos possível), vá desempilhando cada caractere e concatenando nessa nova String. Você obterá o “espelho” da String original. Na verdade é exatamente isso que o reverse() faz, internamente.
Agora compare as duas Strings, se forem iguais é um palíndromo.
if(numeros.equals(numerosInverso)){
// é um palíndromo
}
Cabe a você criar essa classe Pilha, que pelo jeito vai receber caracteres (char). É um bom exercício para estudar conceito de estruturas de dados, e é simples de fazer. A dica é dentro da classe Pilha colocar uma variável int topo, que inicialmente vale -1 e indica onde está o topo da pilha conforme o número de caracteres que foi inserido. o método isEmpty() pode verificar se o topo vale -1. O método push(char a) pode colocar o caractere em vetor[++topo]; e o pop() pode remover o caractere do topo da pilha assim: vetor[topo–]. Eu não vou dar tudo mastigadinho, assim você estuda um pouco.
Divirta-se!
obs: se você resolver o problema e / ou alguém se interessar em como seria essa classe Pilha, eu faço o código para mostrar. Uma pilha criada assim funciona muito rápido.
[quote=Fox McCloud]Uma outra idéia, se o seu professor não quiser que você use recursos prontos, ou se você quiser conhecer outras possibilidades…
Use uma estrutura de dados do tipo PILHA (LIFO - last in first out). Você pode usar algo pronto ou criar um objeto pilha que utiliza um vetor de cinco posições e tem os métodos push() (inserir) e pop() (remover).
Vá pegando cada caractere do String (do 1º ao último) e inserindo um por um na pilha.[/quote]
:shock: Se podemos complicar, pra que simplificar?
Ora, vamos lá, existem ferramentas hoje em dia em que você coloca as necessidades do cliente e ela gera um sistema completo com banco de dados na linguagem que você quiser. Onde estão os verdadeiros programadores?
Ainda que se faça isso uma vez na vida (uma Pilha), para nunca mais, pelo menos é um bom exercício de lógica, além de ficarmos sabendo como o Java fez internamente.
Só uma observação que não tem nada a ver com o problema: palíndromo é usado para palavras que podem ser lidas “de frente pra trás e de trás pra frente”. Para números o termo certo é capícua (http://pt.wikipedia.org/wiki/Capicua).
[quote=Hawk]Ta aí uma coisa que nao consigo imaginar…
usando if, if…else, e/ou while:
Deitel:
4.30 (Palíndromos) Um palíndromo é uma seqüencia de caracteres que é lida da esquerda para a direita, ou da direita para esquerda. Por exemplo, cada um dos seguinter inteiros de cinco dígitos é um palíndromo: 12321, 55555, 45554, 11611. Escreva um aplicativo que leia em um inteiro de cinco de dígitos e determine se ele é ou não um palíndromo. Se o número não for de cinco dígitos, esxiba uma mensagem de erro e permita que o usuário insira um novo valor.
A grande dúvida é… qual a condição que validaria um políndromo??? Precisaria ler caractere por caractere? se sim, como se faz? se não, como???
obrigado.
[/quote]
Segue o código desse exercício:
// Exercício 4.24 Ex4_24.java
// recebe um inteiro de 5 dígitos e imprime uma mensagem dizendo se ele é ou não um palíndromo
import javax.swing.JOptionPane;
public class Ex4_24
{
public static void main ( String args [] )
{
int number, // número inserido pelo usuário
n1, // corresponde ao primeiro digito
n2, // corresponde ao segundo digito
n3, // corresponde ao terceiro digito
n4, // corresponde ao quarto digito
n5; // corresponde ao quinto digito
double num = 0;
// recebe o número do usuário
number = Integer.parseInt (JOptionPane.showInputDialog ("Digite um número com 5 digitos: "));
// verifica se o número tem 5 digitos
while ( number > 99999 )
{
JOptionPane.showMessageDialog ( null, "O número possui mais de cinco dígitos!");
// digita novamente um número
number = Integer.parseInt (JOptionPane.showInputDialog ("Digite um número com 5 digitos: "));
while ( number <= 9999 )
{
JOptionPane.showMessageDialog ( null, "O número possui menos de cinco dígitos!");
// digita novamente um número
number = Integer.parseInt (JOptionPane.showInputDialog ("Digite um número com 5 digitos: "));
}
}
while ( number <= 9999 )
{
JOptionPane.showMessageDialog ( null, "O número possui menos de cinco dígitos!");
// digita novamente um número
number = Integer.parseInt (JOptionPane.showInputDialog ("Digite um número com 5 digitos: "));
while ( number > 99999 )
{
JOptionPane.showMessageDialog ( null, "O número possui mais de cinco dígitos!");
// digita novamente um número
number = Integer.parseInt (JOptionPane.showInputDialog ("Digite um número com 5 digitos: "));
}
}
// fiz um teste com o número 15951
n1 = number / 10000; // 15951 / 10000 = 1
n2 = (number / 1000) - (n1 * 10); // 15951 / 1000 = 15 - 10 = 5
n3 = (number / 100) - (n1 * 100) - (n2 * 10); // 15951 / 100 = 159 - 100 = 59 - 50 = 9
n4 = (number / 10) - (n1 * 1000) - (n2 * 100) - (n3 * 10); // 15951 / 10 = 1595 - 1000 = 595 - 500 = 95 - 90 = 5
n5 = number - (n1 * 10000) - (n2 * 1000) - (n3 * 100) - (n4 * 10); // 15951 - 10000 = 5951 - 5000 = 951 - 900 = 51 - 50 = 1
if (n1 == n5)
{
if (n2 == n4)
{
JOptionPane.showMessageDialog ( null, "O número digitado é um palíndromo!");
}
else
{
JOptionPane.showMessageDialog ( null, "O número digitado não é um palíndromo!");
}
}
else
{
JOptionPane.showMessageDialog ( null, "O número digitado não é um palíndromo!");
}
System.exit ( 0 );
}
}
import java.util.Scanner;
class VerificaPalindrome { // método usando classe String e StringBuffer
static Scanner I = new Scanner(System.in);
public static void main(String args[]){
System.out.print("Digite uma palavra(Para sair digite FIM): ");//pode se digitar um nº também mas lembre-se que
String s = I.nextLine();
int nCont = 0;
StringBuilder sb = new StringBuilder(s);
if(s.equals(sb.reverse().toString()))
{ // equals é um método que compara String
System.out.println("É palindromo") ;// e sb e sb.reverse são StringBuffer por
nCont++;
System.out.println("Contabilizados " + nCont + " palindromos");
System.out.println("------------");
}
else { // isso .toString pra converter
System.out.println("Não é palindromo");
System.out.println("Contabilizados " + nCont + " palindromos");
System.out.println("------------");
while(!s.equals("fim")){
System.out.print(("Digite uma palavra(Para sair digite FIM): "));//pode se digitar um nº também mas lembre-se que
s = I.nextLine();
sb = new StringBuilder(s);
if (s.equals(sb.reverse().toString())){ // equals é um método que compara String
System.out.println("É palindromo") ;// e sb e sb.reverse são StringBuffer por
nCont++;
System.out.println("Contabilizados " + nCont + " palindromos");
System.out.println("------------");
}
else { // isso .toString pra converter
System.out.println("Não é palindromo");
System.out.println("Contabilizados " + nCont + " palindromos");
System.out.println("------------");
}
}
}
}
}
Segue uma solução para esta capícua (como bem informado pelo David neste tópico) e que aprendi ao fazer o (exerc 2.30 - pág. 54) do próprio Deitel,
import java.util.Scanner;
public class Palindromo {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int valorUsuario, quinto, quarto, terceiro, segundo, primeiro;
System.out.print("Informe um valor inteiro de 5 casas: ");
valorUsuario = input.nextInt();
while (valorUsuario < 10000 || valorUsuario > 99999){
System.out.print("Entrada Inválida! Informe um valor inteiro de 5 casas: ");
valorUsuario = input.nextInt();
}
quinto = valorUsuario % 10;
valorUsuario /= 10;
quarto = valorUsuario % 10;
valorUsuario /= 10;
terceiro = valorUsuario % 10;
terceiro = terceiro + 0;// isso é besteira, somente para não exibir Warning
valorUsuario /= 10;
segundo = valorUsuario % 10;
valorUsuario /= 10;
primeiro = valorUsuario % 10;
if (primeiro == quinto && segundo == quarto){
System.out.println();
System.out.println("O número é um palíndromo!");
} else {
System.out.println();
System.out.println("O número não é um palíndromo!");
}
}
}
