Quiero comprobar si una cuerda es un palíndromo o no. Me gustaría aprender un método fácil para verificar lo mismo usando la menor manipulación posible de cadenas

2

Utilizando reverse es excesivo porque no necesita generar una cadena adicional, solo necesita consultar la existente. El siguiente ejemplo verifica que el primer y último carácter sean iguales y luego camina más dentro de la cadena verificando los resultados cada vez. Vuelve tan pronto como s no es un palíndromo.

El problema con el reverse enfoque 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 entonces devuelve falso si no es un palíndromo. Si solo está comparando cadenas pequeñas todo el tiempo, esto está bien, pero si desea defenderse de una entrada más grande, debe 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;
}

12

Para la menor cantidad de líneas de código y el caso más simple

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

1

Aquí hay uno 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;
    }
}

Puedes probar 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

2

Aquí tienes 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.

1

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

Supongo que esta es una forma sencilla de comprobar el palíndromo.

String strToRevrse = "MOM";

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

Soy nuevo en Java y estoy tomando su pregunta como un desafío para mejorar mis conocimientos también, así que 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 cuerda no tiene letras o solo tiene una letra, es un palíndromo.
  2. De lo contrario, compare la primera y la última letra de la cadena.
    • Si la primera y la última letra difieren, entonces la cuerda no es un palíndromo.
    • De lo contrario, la primera y la última letra son iguales. Quítelos de la cuerda y determine si la cuerda que queda es un palíndromo. Tome la respuesta para esta cadena más pequeña y úsela como la respuesta para la cadena original, luego repita desde 1.

La única manipulación de la cadena es cambiar la cadena a mayúsculas para que pueda ingresar algo como ‘XScsX’

comprobar esta condición

String string = «// alguna cadena … //»

marque esto … if (string.equals ((string.reverse ()) {es palíndromo}

1

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;
}