forma de Java para comprobar si una cadena es palindrome

Question

Quiero comprobar si una cadena es un palíndromo o no. Me gustaría aprender un método sencillo para comprobar las mismas que usan posibles manipulaciones menos cuerda

Answer 1

Usted puede intentar algo como esto:

String variable = ""; #write a string name 

    StringBuffer rev = new StringBuffer(variable).reverse(); 

    String strRev = rev.toString(); 

    if(variable.equalsIgnoreCase(strRev)) # Check the condition 

Answer 2

Aquí es una buena clase:

public class Palindrome { 

    public static boolean isPalindrome(String stringToTest) { 
    String workingCopy = removeJunk(stringToTest); 
    String reversedCopy = reverse(workingCopy); 

    return reversedCopy.equalsIgnoreCase(workingCopy); 
    } 

    protected static String removeJunk(String string) { 
    int i, len = string.length(); 
    StringBuffer dest = new StringBuffer(len); 
    char c; 

    for (i = (len - 1); i >= 0; i--) { 
     c = string.charAt(i); 
     if (Character.isLetterOrDigit(c)) { 
     dest.append(c); 
     } 
    } 

    return dest.toString(); 
    } 

    protected static String reverse(String string) { 
    StringBuffer sb = new StringBuffer(string); 

    return sb.reverse().toString(); 
    } 

    public static void main(String[] args) { 
    String string = "Madam, I'm Adam."; 

    System.out.println(); 
    System.out.println("Testing whether the following " 
     + "string is a palindrome:"); 
    System.out.println(" " + string); 
    System.out.println(); 

    if (isPalindrome(string)) { 
     System.out.println("It IS a palindrome!"); 
    } else { 
     System.out.println("It is NOT a palindrome!"); 
    } 
    System.out.println(); 
    } 
} 

disfrutar.

Answer 3

El uso de reverse es exagerado porque no necesita generar una cadena adicional, solo necesita consultar la existente. El siguiente ejemplo verifica que el primero y el último caracteres sean iguales, y luego camina más adentro de la cadena comprobando los resultados cada vez. Vuelve tan pronto como s no es un palíndromo.

El problema con el enfoque reverse es que hace todo el trabajo por adelantado. Realiza una acción costosa en una cadena, luego verifica carácter por carácter hasta que las cadenas no son iguales y solo luego devuelve falso si no es un palíndromo. Si solo estás comparando cadenas pequeñas todo el tiempo, entonces está bien, pero si quieres defenderte contra una entrada más grande, entonces deberías considerar este algoritmo.

boolean isPalindrome(String s) { 
    int n = s.length(); 
    for (int i = 0; i < (n/2); ++i) { 
    if (s.charAt(i) != s.charAt(n - i - 1)) { 
     return false; 
    } 
    } 

    return true; 
} 

Answer 4

para los menos líneas de código y el caso más simple

if(s.equals(new StringBuilder(s).reverse().toString())) // is a palindrome. 

Answer 5

comprobar esta condición

cordaje = "// alguna cadena ... //"

cheque esto ... if (string.equals ((string.reverse()) { es palindrome }

Answer 6

supongo que esto es la forma sencilla de comprobar palíndromo

String strToRevrse = "MOM"; 

strToRevrse.equalsIgnoreCase(new StringBuilder(strToRevrse).reverse().toString()); 

Answer 7

public static boolean istPalindrom(char[] word){ 
int i1 = 0; 
int i2 = word.length - 1; 
while (i2 > i1) { 
    if (word[i1] != word[i2]) { 
     return false; 
    } 
    ++i1; 
    --i2; 
} 
return true; 
} 

Answer 8

import java.util.Scanner; 

public class FindAllPalindromes { 
static String longestPalindrome; 
public String oldPalindrome=""; 
static int longest; 

public void allSubstrings(String s){   
    for(int i=0;i<s.length();i++){ 
     for(int j=1;j<=s.length()-i;j++){ 
      String subString=s.substring(i, i+j); 
      palindrome(subString);    
     } 
    } 
     } 
public void palindrome(String sub){ 
    System.out.println("String to b checked is "+sub); 
    StringBuilder sb=new StringBuilder(); 
    sb.append(sub);  // append string to string builder 
    sb.reverse();   
    if(sub.equals(sb.toString())){      // palindrome condition 
     System.out.println("the given String :"+sub+" is a palindrome"); 
     longestPalindrome(sub); 
    } 
    else{ 
     System.out.println("the string "+sub+"iss not a palindrome"); 
    } 
     } 
public void longestPalindrome(String s){ 
      if(s.length()>longest){     
     longest=s.length(); 
     longestPalindrome=s; 

    } 
    else if (s.length()==longest){  
     oldPalindrome=longestPalindrome; 
     longestPalindrome=s; 

    } 




} 

public static void main(String[] args) { 
FindAllPalindromes fp=new FindAllPalindromes(); 

    Scanner sc=new Scanner(System.in);  
    System.out.println("Enter the String ::"); 
    String s=sc.nextLine(); 
    fp.allSubstrings(s);  
    sc.close(); 
    if(fp.oldPalindrome.length()>0){ 
    System.out.println(longestPalindrome+"and"+fp.oldPalindrome+":is the longest palindrome"); 
    } 
    else{ 
     System.out.println(longestPalindrome+":is the longest palindrome`````"); 
    }} 
} 

Answer 9

Aquí es una simple"

public class Palindrome { 

    public static void main(String [] args){ 
     Palindrome pn = new Palindrome(); 

     if(pn.isPalindrome("ABBA")){ 
      System.out.println("Palindrome"); 
     } else { 
      System.out.println("Not Palindrome"); 
     } 
    } 

    public boolean isPalindrome(String original){ 
     int i = original.length()-1; 
     int j=0; 
     while(i > j) { 
      if(original.charAt(i) != original.charAt(j)) { 
       return false; 
      } 
      i--; 
      j++; 
     } 
     return true; 
    } 
} 

Answer 10

soy nuevo en java y estoy tomando su pregunta como un desafío para mejorar mi conocimiento también, así que por favor, perdóneme si esto no responde bien a su pregunta:

import java.util.ArrayList; 
import java.util.List; 

public class PalindromeRecursiveBoolean { 

    public static boolean isPalindrome(String str) { 

     str = str.toUpperCase(); 
     char[] strChars = str.toCharArray(); 

     List<Character> word = new ArrayList<>(); 
     for (char c : strChars) { 
      word.add(c); 
     } 

     while (true) { 
      if ((word.size() == 1) || (word.size() == 0)) { 
       return true; 
      } 
      if (word.get(0) == word.get(word.size() - 1)) { 
       word.remove(0); 
       word.remove(word.size() - 1); 
      } else { 
       return false; 

      } 

     } 
    } 
} 

1. Si la cadena no está hecha de letras o de una sola letra, es palindrome.
2. De lo contrario, compare la primera y la última letra de la cadena.
   • Si la primera y la última letra son diferentes, la cadena no es un palíndromo
   • De lo contrario, la primera y la última letra son las mismas. Elimínalos de la cadena y determina si la cadena que queda es un palíndromo. Tome la respuesta para esta cadena más pequeña y úsela como respuesta para la cadena original y luego repita desde .

La única manipulación de cadenas está cambiando la cadena a mayúsculas para que pueda entrar en algo así como 'XScsX'

Answer 11

public boolean isPalindrom(String text) { 
    StringBuffer stringBuffer = new StringBuffer(text); 
    return stringBuffer.reverse().toString().equals(text); 
}