PALINDROME

public class Palindrome {

private String pal;

public Palindrome(String initPal) {

pal = initPal.toUpperCase();
}

public boolean isPalindrome() {

if (pal.length() <= 1) {
// String has only one character so it
// is a Palindrome by definition.
return true; // BASE CASE.
}

// Get the first and last characters of the String.

char first = pal.charAt(0);
char last = pal.charAt(pal.length()-1);

if (Character.isLetter(first) &&
Character.isLetter(last)) {
// The first and last characters are both letters..

if (first != last) {
// The first and last letters are different
// so the string is not a Palindrome.
return false; // BASE CASE.
}
else {
// The first and last characters are both letters,
// and they are both the same. So, the string is
// a palindrome if the substring created by dropping
// the first and last characters is a palindrome.
Palindrome sub = new Palindrome(
pal.substring(1,pal.length()-1));
return sub.isPalindrome(); // RECURSIVE CASE.
}
}
else if (!Character.isLetter(first)) {
// The first character in the string is not a letter.
// So the string is a palindrome if the substring created
// by dropping the first character is a palindrome.
Palindrome sub = new Palindrome(pal.substring(1));
return sub.isPalindrome(); // RECURSIVE CASE.
}
else {
// The last character in the string is not a letter.
// So the string is a palindrome if the substring created
// by dropping the last character is a palindrome.
Palindrome sub = new Palindrome(
pal.substring(0,pal.length()-1));
return sub.isPalindrome(); // RECURSIVE CASE.
}
}

public static void main(String[] args) {

Palindrome p1 = new Palindrome("Madam, I'm Adam.");
System.out.println(p1.isPalindrome());
Palindrome p2 = new Palindrome("Nope!");
 System.out.println(p2.isPalindrome());
Palindrome p3 = new Palindrome("dad");
System.out.println(p3.isPalindrome());
Palindrome p4 = new Palindrome("Go hang a salami, I'm a lasagna
hog.");
System.out.println(p4.isPalindrome());
}
}

Práctica N° 5: Palíndromo
By Luis Alberto Ochoa on September 28, 2009

Elaborar una función recursiva que permita detectar si una frase o palabra es
palíndromo.

Debemos saber que un palíndromo es una frase número o palabra que se lee igual hacia
adelante que hacia atrás.

Algunas palabras y freses son: ana, rotor, salas, seres, somos y la frase favorita de
todos: anita lava la tina.

1 package org.luisalberto.laboratorio.practica5;
2  
public class Palindromo {
3
4  
    public static boolean esPalindromo(String palabra) {
5
 
6         palabra = palabra.toLowerCase();
7  
8         if (palabra.length() <= 1)
9             return true;
1  
0         char primerLetra = palabra.charAt(0);
        char ultimaLetra = palabra.charAt(palabra.length() - 1);
1
1  
        if (Character.isLetter(primerLetra) &&
1 Character.isLetter(ultimaLetra))
2             if (primerLetra != ultimaLetra)
1                 return false;
3             else
            {
1                 String pal = palabra.substring(1, palabra.length() -
4 1);
1                 return esPalindromo(pal);
5             }
            else if (!Character.isLetter(primerLetra))
1             {
6                 String pal = palabra.substring(1);
1                 return esPalindromo(pal);
7             }
1             else
            {
8                 String pal = palabra.substring(0, palabra.length() -
1 1);
9                 return esPalindromo(pal);
2             }
0     }
2  
    public static void main(String[] args) {
1         String palabra = "anita lava la tina";
2  
2         if (esPalindromo(palabra))
2             System.out.println("Si es palindromo");
3         else
2             System.out.println("No es palindromo");
4  
    }
2 }
5
2
6
2
7
2
8
2
9
3
0
3
1
3
2
3
3
3
4
3
5
3
6
3
7
3
8
3
9
4
0
4
1
4
2
4
3
4
4
$ javac -d . Palindromo.java
$ java org.luisalberto.laboratorio.practica5.Palindromo
Si es palindromo

Ejercicio resuelto: Palindromo en java

06/12/09. Publicado por Mouse en 17:46

Escribe una clase en java para determinar si una palabra o frase es palindroma.

Respuesta:
Un palíndromo es una palabra, número o frase que se lee igual hacia adelante que hacia
atrás. Habitualmente, las frases palindrómicas se resienten en su significado cuanto más
largas son.

El clasico ejemplo es: anita lava la tina

Nuestra clase se llama "palindromo.java", recibe como parametro una cadena, si esta
cadena tiene espacios en blanco los elimina, despues realiza una comparacion caracter
por caracter determinando si corresponde a un palindromo o no, devuelve TRUE si es
un palindromo, FALSE caso contrario.

/**
 * @web http://jc-mouse.blogspot.com
 * @author mouse
 */
public class palindromo {

public boolean espalindromo(String cadena){

    boolean valor=true;
    int i,ind;    
    String cadena2="";
    //quitamos los espacios
    for (int x=0; x < cadena.length(); x++) {
        if (cadena.charAt(x) != ' ')
            cadena2 += cadena.charAt(x);
    }
    //volvemos a asignar variables
    cadena=cadena2;    
    ind=cadena.length();
    //comparamos cadenas
    for (i= 0 ;i < (cadena.length()); i++){        
       if (cadena.substring(i, i+1).equals(cadena.substring(ind - 1,
ind)) == false ) {
           //si una sola letra no corresponde no es un palindromo por
tanto
           //sale del ciclo con valor false
            valor=false;
            break;
       }
       ind--;
    }
    return valor;
}
}

Nuestro main:

/**
 * @web http://jc-mouse.blogspot.com
 * @author mouse
 */
public class Main {
    
    public static void main(String[] args) {              
        palindromo objclass=new palindromo();
        if(objclass.espalindromo("la ruta nos aporto otro paso
natural")){
            System.out.println("Palindromo");
        }
        else
        {
            System.out.println("No Palindromo");
        }
    }    
}

Frases palindromos para que pruebes

"adivina ya te opina ya ni miles origina ya ni cetro me domina ya ni monarcas a repaso

ni mulato carreta acaso nicotina ya ni cita vecino anima cocina pedazo gallina cedazo
terso nos retoza de canilla goza de panico camina onice vaticina ya ni tocino saca a
terracota luminosa pera sacra nomina y animo de mortecina ya ni giros elimina ya ni
poeta ya ni vida" (de Ricardo Ochoa)

"no di mi decoro cedi mi don" (de Juan Filloy)

"nada yo soy adan" (de Guillermo Cabrera Infante)

"atale demoniaco cain o me delata" (de Julio Cortazar)

"alli por la tropa portado traido a ese paraje de maniobras una tipa como capitan usar
boina me dejara pese a odiar toda tropa por tal ropilla" (de Luis Torrent)

bueno mi pregunta es porque el siguiente codigo aun cuando hace bien la inversion de la
palabra y cuando en teoria deberia funcionar porque el codigo siempre dice que la
palabra es palindromo aun cuando no lo es ???
#include <stdio.h>
#include <iostream.h>

int main () {
  int j,i;
  char frase[50],cadena [50]];
  bool temp = false;
    
   printf ("Introduzca una cadena: ");
    scanf("%s",&cadena);
    
    for(i=0;i<strlen(cadena);i++) {
    

j = (strlen(cadena)-1)-i;
   

  frase[i] = cadena[j];
   

   if(frase[i] == cadena[j]) {
       temp = true;

}
      else {
     temp = false;
    }
   } 

 if(temp == true) {
  cout << "la palabra es palindromo";
 }
else {
  cout << "La palabra no es palindromo";
 }
cout << "\n";
  return 0;
}

la logica del programa es sencilla lo que hago es tomar la palabra escrita por el usuario e
invertirla y guardarla en otro array de caracteres para luego hacer la comparacion para
ver si las palabras son identicas de derecha a izquierda y de izquierda a derecho luego
en una variable del tipo bool guardo true si son identicas y false si no lo son pero por
algun motivo que aun desconozco siempre me dice que es palindromo

http://foro.elhacker.net/programacion_cc/ayuda_en_codigo_de_palindromo-
t223967.0.html;msg1063490#ixzz1EkQK0HwM
ahi te lo dejo... La verdad das muchas vueltas para llegar al mismo lugar y combinas
mucho c con c++

Ahi te queda, aunque creo que se puede simplificar mas

Código

http://foro.elhacker.net/programacion_cc/ayuda_en_codigo_de_palindromo-
t223967.0.html;msg1063490#ixzz1EkQMu3JN

#include <iostream>
#include <string.h>
 
using namespace std;
int main () {
 char frase[50],cadena [50] ;
 
  cout << "Introduzca una cadena: ";
  cin.get(cadena,50);
 
   for(int i=strlen(cadena)-1;i>=0;i--) {
  frase[strlen(cadena)-1-i] = cadena[i];
    }
if(*frase == *cadena) {
 cout << "la palabra es palindromo\n";
}
else {
 cout << "La palabra no es palindromo\n";
}
 return 0;
}
 

http://foro.elhacker.net/programacion_cc/ayuda_en_codigo_de_palindromo-
t223967.0.html;msg1063490#ixzz1EkQRF77u

Palíndromos en Java
Un palíndromo es una palabra, número o frase que se lee igual de izquierda a derecha o
de derecha a izquierda. Un ejemplo clásico es “Dábale arroz a la zorra el abad”, o
como dijeron en los Simpson “Anita lava la tina”. También palabras como “ala” o
números como “2002″.

Lo que este código hace es leer una línea y ver si ordenándola de alguna manera se
puede generar un palíndromo, por ejemplo “Yoga hoy yo hago” NO es un palíndromo,
pero si lo ordenamos de esta forma “Yo hago yoga hoy” obtenemos una frase que SI es
un palíndromo. Para hacer esto me resultó útil parte del código que publiqué en el post
“Anagramas en Java” ya que lo que hago es probar todas las conjugaciones que se
pueden hacer con las palabras de la frase ingresada y luego ver si alguna(s) de ellas es
un palíndromo.

Es una solución que usa fuerza bruta y se puede mejorar fácilmente, por ejemplo
detectando si para la primera palabra de una conjugación hay otra palabra que acabe con
la misma letra (“Sx xxxx xx xx xx xxs”) y no hacer conjugaciones en vano, pero esa es
otra historia.

Este código lee un número n de casos y luego imprime los parónimos que se pueden
obtener ordenando las palabras de alguna manera. Para evitar palíndromos repetidos
(por ejemplo si ponemos “a a b” podríamos tener 2 veces “a b a” – “a b a”) seguí la
recomendación de Pedro en “Anagramas en Java” y almacené todos los palídromos en
un Set y así evitamos los repetidos =D. Si no hay ningún palíndromo posible se muestra
el mensaje “imposible”.

PD: El código no funciona con tildes (bienvenido el que quiera agregar los replace() ).

?
00 import java.io.*;
import java.util.HashSet;
1
00  
public class Palindromos {
2     public static void main(String[] args) throws IOException {
00         BufferedReader br=new BufferedReader(new
3         InputStreamReader(System.in));
00         System.out.println("Ingrese el numero de lineas:");
        int nro= Integer.parseInt(br.readLine());
4         for (int i=0;i<nro;i++){
00             String cadena=br.readLine();
5             //Pasamos todas las letras a mayuscula para no hacer
00 distincion
6             cadena=cadena.toUpperCase();
            //Un arreglo con cada palabra
00             String[] palabras=cadena.split(" ");
7             //Una variable de control para el método recursivo
00             //que se va a usar
8             int veces=0;
            //Un arreglo de cadenas que se usará para
00             //hacer conjugaciones
9             String[] conjugacion= new String[palabras.length];
01             //Un Set donde se almacenarán las conjugaciones
0             //y permitirá identificar repetidos
01             HashSet<String> palindromos=new HashSet<String>();
            //El méttodo recursivo
1             conjugar(palabras, veces,conjugacion,palindromos);
01             //Output
2             if (palindromos.isEmpty()){
01                 System.out.println("imposible");
3             }else{
                System.out.println("Palindromos encontrados: ");
01                 for(String pal:palindromos){
4                     System.out.println("- "+pal);
01                 }
5             }
        }
01     }
6  
    public static void conjugar(String[] palabras, int veces,
01             String[] conjugacion, HashSet<String> palindromos){
7         //Si la conjugacion está completa, probamos si es
01 palíndromo
8         if (veces==palabras.length){
01             probarPalindromo(conjugacion,palindromos);
            return;
9         }
02         //Desde aquí es casi idéntico que el código del anagrama
0         veces++;
02         for (int i=0; i<=palabras.length-1;i++){
1             if (palabras[i].compareTo("@")==0){
                continue;
02             }else{
2                 String palabraAuxiliar=palabras[i];
02                 conjugacion[veces-1]=palabraAuxiliar;
3                 palabras[i]="@";
                conjugar(palabras,veces,conjugacion,palindromos);
02                 palabras[i]=palabraAuxiliar;
4             }
02         }
5     }
02  
6     public static void probarPalindromo(String[] conjugacion,
            HashSet<String> palindromos){
02         //Armamos una cadena en base al arreglo de Strings
7         //La cadena no tendrá espacios entre letras,
02         //ya que para ser palíndromo
8         //estas no se toman en cuenta
02         String cadena1="";
        for (String s:conjugacion){
9             cadena1=cadena1+s;
03         }
0         int veces;
03         //Luego lo pasamos a un arreglo de caracteres
        //para hacer las comparaciones
1         //Esto se puede hacer de varias maneras
03         char[] carac=cadena1.toCharArray();
2         int longitud=carac.length;
03         if (longitud % 2==0){
3             veces=longitud/2;
        }else{
03             veces=(longitud-1)/2;
4         }
03         //Una bandera que indica que no es palindromo
5         boolean flagNoPalindromo=false;
        for(int i=0;i<=veces;i++){
03
            //La idea es comparar el primer caracter con el último
6             //Luego el segundo con el penúltimo, etc etc
03             if (carac[i]==carac[longitud-i-1]){
7             }else{
03                 flagNoPalindromo=true;
            }
8         }
03         if (flagNoPalindromo==true){
9             return;
04         }
0         //Armamos otra cadena, ahora los espacios entre letras
        String cadenaSalida="";
04         for (String s:conjugacion){
            cadenaSalida=cadenaSalida+s+" ";
1         }
04         //Finalmente le damos un poco de formato y lo agregamos al
2 Set
04         String cadenaFormateada=cadenaSalida.substring(0,1)+
3                 cadenaSalida.substring(1,
                cadenaSalida.length()-1).toLowerCase();
04         cadenaFormateada="\""+ cadenaFormateada+"\"";
4         palindromos.add(cadenaFormateada);
04     }
5 }
04
6
04
7
04
8
04
9
05
0
05
1
05
2
05
3
05
4
05
5
05
6
05
7
05
8
05
9
06
0
06
1
06
2
06
3
06
4
06
5
06
6
06
7
06
8
06
9
07
0
07
1
07
2
07
3
07
4
07
5
07
6
07
7
07
8
07
9
08
0
08
1
08
2
08
3
08
4
08
5
08
6
08
7
08
8
08
9
09
0
09
1
09
2
09
3
09
4
09
5
09
6
09
7
09
8
09
9
10
0
10
1
10
2
10
3
10
4
10
5
10
6
10
7

Elegida por el usuario que pregunta

Ejemplo 1: Para saber si una cadena es o no palindromo

/**
* Dada la cadena s, devuelve true si es palíndromo,
* false en otro caso.
*/
public static boolean isPalindrome(String s) {
char[] cs = s.toCharArray();
int n = cs.length;

// i, desde el principio
// j, desde el final
int i=0, j=n-1;
for (; i<=j && cs[i]==cs[j]; i++, j--);

return i>=j;
}

Ejemplo 2: Saber si un número es palíndromo, es sencillo, empleando el método anterior.

/**
* Dada el número l, devuelve true si es palíndromo,
* false en otro caso.
*/
public static boolean isPalindrome(long l) {
return isPalindrome(Long.toString(l));
}

Ejemplo 3: Puede ser útil precalcular todos los palíndromos de una cadena, para posteriores
usos. El siguiente método lo hace.

/**
* Devuelve todos los palíndromos de una cadena
* pasada por parámetro en un array de booleanos
* de dos dimensiones.
* allPalindromes[i][j]== true si la subcadena que
* empieza en i con longitud j es palíndromo, false
* en otro caso.
* 0<=i<n, 0<=j<=n
*/
public static boolean[][] allPalindromes(String s) {

char[] cs = s.toCharArray();
int n = cs.length;
boolean[][] isPalin = new boolean[n][n+1]; // start position, length;

for (int l = 1; l <= n; l++){

for (int i = 0; i + l <= n; i++) {
int first = i, last = i+l-1;
for (; i<=last && cs[first]==cs[last];first++, last--);
isPalin[i][l]=(first>=last);
}
}

return isPalin;
}

El método anterior es muy ineficiente. Para este caso es muy útil emplear la programación
dinámica, que almacena y utiliza resultados ya calculados anteriormente. Sabemos que:

- isPalindrome[i][0] = false: Si la longitud es 0, no es palíndromo.

- isPalindrome[i][1] = true: Todo carácter individual (longitud 1) es palíndromo.
- isPalindrome[i][2] = (cs[i]==cs[i+1]): Todo palíndromo de longitud 2 se da si caracteres
consecutivos son iguales.
- isPalin[i][j] = isPalin[i+1][j-2] && cs[i]==cs[i+j-1].

/**
* Devuelve todos los palíndromos de una cadena
* pasada por parámetro en un array de booleanos
* de dos dimensiones.
* allPalindromes[i][j]== true si la subcadena que
* empieza en i con longitud j es palíndromo, false
* en otro caso.
* 0<=i<n, 0<=j<=n
*/
public static boolean[][] allPalindromesDP(String s) {

char[] cs = s.toCharArray();
int n = cs.length;
boolean[][] isPalin = new boolean[n][n+1]; // start position, length;

for (int i=0; i<n; i++) isPalin[i][0]=false;

for (int i=0; i<n; i++) isPalin[i][1]=true;
for (int i=0; i<n-1; i++) isPalin[i][2]=(cs[i]==cs[i+1]);

for (int j=3; j<=n; j++) {

for (int i=0; i<n-j+1; i++) {
isPalin[i][j] = isPalin[i+1][j-2] && cs[i]==cs[i+j-1];
}
}
return isPalin;
}

Ejemplo 4: Este problema hace uso intensivo del precálculo de palíndromos. Se pretende
averiguar el número mínimo de particiones en que se puede dividir una cadena, tal que cada
partición sea un palíndromo.
Aplicando programación dinámica. Si r[i] es la solución al problema descrito para la subcadena
de 0 a i, r[i]=min(r[i-j]+1), con 1<=j<=i.

/**
* Devuelve el mínimo número de particiones de s
* tal que cada partición sea un palíndromo.
*/
public static int minPartitions(String s) {

int n = s.length();
boolean[][] isPalin = allPalindromesDP(s);
int[] r = new int[n+1];

r[0] = 0;
r[1] = 1;

for (int i=2; i<=n; i++) {

r[i] = Integer.MAX_VALUE;
for (int j=1; j<=i; j++) {
if (isPalin[i-j][j]) r[i]=Math.min(r[i], r[i-j]+1);
}
}

return r[n];
}

Ejemplo 5: Un palíndromo numérico es un número que se lee igual tanto de izquierda a

derecha como de derecha a izquierda. Por ejemplo, los números 1234321 y 12344321 son
palíndromos. El siguiente método, dado un número, devuelve el palíndromo formado con él.

/**
* Dado un número, genera un palíndromo con él.
* Implementación en Java.
* El palíndromo se genera de dos maneras:
* - EVEN: devuelve un palíndromo con número par de dígitos.
* return concat(n, n.reverse)
* - ODD: devuelve un palíndromo con número impar de dígitos.
* return concat(n, (n / 10).reverse)
* Este algoritmo tiene un orden de O(m), dónde m es el número
* de dígitos de n, el generador del palíndromo.
*
* @param n Número generador del palíndromo.
* @param even TRUE, devuelve un palíndromo con número par
* de dígitos; FALSE, devuelve un palíndromo con número impar
* de dígitos.
* @return Palíndromo generado.
*/
public static long getPalindrome(long n, boolean even) {
long aux = (even) ? n : n / 10;
long pow = 1;
long nright = 0;
while (aux > 0) {
nright = (nright * 10) + (aux % 10);
aux /= 10;
pow *= 10;
}

return (n * pow) + nright;

}

Ejemplo 6:

/*
Clase que chequea si una palabra es palindroma
usando pilas y colas
*/
import java.io.*;
class Cola
{
char Cola[];
int Frente;
int Final;
int Nulo;
int MaxCola=20;
public Cola()
{
Cola=new char[MaxCola+1];
MaxCola=MaxCola-1;
Nulo=-1;
Frente=Nulo;
Final=Nulo;
}

public void Meter(char Elemento)

{
if((Frente==0&&Final==MaxCola)||(Frent…
{
System.out.println("Desbordamiento de memoria");
return;
}else
{
if(Frente==Nulo)
{
Frente=0;
Final=0;
}else if(Final==MaxCola)
Final=0;
else
Final+=1;
Cola[Final]=Elemento;
}
}

public char Sacar()

{
char aux;
if(Frente==Nulo)
{
System.out.println("Cola Vacia");
return 0;
}else
{
aux=Cola[Frente];
if(Frente==Final)
{
Frente=Nulo;
Final=Nulo;
}else if(Frente==MaxCola)
Frente=0;
else
Frente+=1;
return aux;
}
}
}

class Pila{
private static final int TAMPILA=20;
private int cima;
private char []listaPila;

public Pila(){
cima=-1;
listaPila= new char[TAMPILA];
}
public void insertar(char elemento) throws Exception{
if (pilaLlena()){
throw new Exception("Desbordamiento pila");
}
cima++;
listaPila[cima] = elemento;
}
public char quitar() throws Exception{
char aux;
if (pilaVacia()){
throw new Exception ("pila vacia, no se puede extraer");
}
aux = listaPila[cima];
cima--;
return aux;
}

public boolean pilaVacia(){

return cima == -1;
}
public boolean pilaLlena(){
return cima == TAMPILA-1;
}
}
class Palindromo{
public static void main(String [] ramms){
Pila pilaChar;
Cola colaChar;
char ch;
boolean esPal=false;
String pal;
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
try{
pilaChar = new Pila(); //crea pila vacia
colaChar = new Cola(); //crea Cola Vacia
System.out.print("Teclea la palabra a verificar si es palindromo: ");
System.out.flush();
pal = entrada.readLine();
for (int i=0; i<pal.length(); )
{
ch=pal.charAt(i++);
pilaChar.insertar(ch);
colaChar.Meter(ch);
}
//se comprueba si es palindromo
for(int i=0;i<pal.length();i++)
{
if(pilaChar.quitar()==colaChar.Sacar()…
{
esPal=true;
break;
}
else
{
esPal=false;
break;
}
}

if (esPal)
System.out.println("La palabra " + pal + " es un palindromo
\n");
else
System.out.println("La palabra " + pal + " no es un
palindromo \n");
}
catch (Exception er) {
System.err.println("Exception: " + er);
}
}
}

Profesora MFV

Suerte!!