java - saber - Comprobar la cadena de palíndromo

palíndromo ejemplos en java

Question

Un palindrome es una palabra, frase, número u otra secuencia de unidades que se pueden leer de la misma manera en cualquier dirección.

Para comprobar si una palabra es un palíndromo, obtengo la matriz de caracteres de la palabra y comparo los caracteres. Lo probé y parece funcionar. Sin embargo, quiero saber si es correcto o si hay algo que mejorar.

Aquí está mi código:

public class Aufg1 {
    public static void main(String[] args) {
        String wort = "reliefpfpfeiller";
        char[] warray = wort.toCharArray(); 
        System.out.println(istPalindrom(warray));       
    }

    public static boolean istPalindrom(char[] wort){
        boolean palindrom = false;
        if(wort.length%2 == 0){
            for(int i = 0; i < wort.length/2-1; i++){
                if(wort[i] != wort[wort.length-i-1]){
                    return false;
                }else{
                    palindrom = true;
                }
            }
        }else{
            for(int i = 0; i < (wort.length-1)/2-1; i++){
                if(wort[i] != wort[wort.length-i-1]){
                    return false;
                }else{
                    palindrom = true;
                }
            }
        }
        return palindrom;
    }
}

Answer 1

Fragmento de código:

import java.util.Scanner;

 class main
 {
    public static void main(String []args)
    {
       Scanner sc = new Scanner(System.in);
       String str = sc.next();
       String reverse = new StringBuffer(str).reverse().toString();

        if(str.equals(reverse))
            System.out.println("Pallindrome");
        else
            System.out.println("Not Pallindrome");
     }
}

Answer 2

¡Es increíble cuántas soluciones diferentes existen para un problema tan simple! Aqui hay otro más.

private static boolean palindrome(String s){
    String revS = "";
    String checkS = s.toLowerCase();
    String[] checkSArr = checkS.split("");

    for(String e : checkSArr){
        revS = e + revS;
    }

    return (checkS.equals(revS)) ? true : false;
}

Answer 3

¿Por qué no solo?

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

Ejemplo:

La entrada es "andna".
i1 será 0 e i2 será 4.

Primera iteración de ciclo compararemos la word[0] y la word[4] . Son iguales, por lo que incrementamos i1 (ahora es 1) y disminuimos i2 (ahora son 3).
Entonces, comparamos las n. Son iguales, por lo que incrementamos i1 (ahora es 2) y disminuimos i2 (son 2).
Ahora i1 e i2 son iguales (ambos son 2), por lo que la condición para el ciclo while ya no es verdadera, por lo que el ciclo termina y regresamos a verdadero.

Answer 4

Al revisar el palíndromo para la primera mitad de la cuerda con el resto, este caso supone la eliminación de cualquier espacio en blanco.

public int isPalindrome(String a) {
        //Remove all spaces and non alpha characters
        String ab = a.replaceAll("[^A-Za-z0-9]", "").toLowerCase();
        //System.out.println(ab);

        for (int i=0; i<ab.length()/2; i++) {
            if(ab.charAt(i) != ab.charAt((ab.length()-1)-i)) {
                return 0;
            }
        }   
        return 1;
    }

Answer 5

Alternativamente, recursión .

Para cualquiera que esté buscando una solución recursiva más corta, para verificar si una cadena dada satisface como un palíndromo:

private boolean isPalindrome(String s) {
    int length = s.length();

    if (length < 2) // If the string only has 1 char or is empty
        return true;
    else {
        // Check opposite ends of the string for equality
        if (s.charAt(0) != s.charAt(length - 1))
            return false;
        // Function call for string with the two ends snipped off
        else
            return isPalindrome(s.substring(1, length - 1));
    }
}

O incluso más corto , si lo desea:

private boolean isPalindrome(String s) {
    int length = s.length();
    if (length < 2) return true;
    else return s.charAt(0) != s.charAt(length - 1) ? false :
            isPalindrome(s.substring(1, length - 1));
}

Answer 6

Aquí mi análisis de la respuesta @Greg: componentsprogramming.com/palindromes

Sidenote: Pero, para mí, es importante hacerlo de una manera Genérica . Los requisitos son que la secuencia sea bidireccionalmente iterable y los elementos de la secuencia sean comparables usando la igualdad. No sé cómo hacerlo en Java, pero aquí hay una versión de C ++. No conozco una mejor manera de hacerlo para secuencias bidireccionales.

template <BidirectionalIterator I> 
    requires( EqualityComparable< ValueType<I> > ) 
bool palindrome( I first, I last ) 
{ 
    I m = middle(first, last); 
    auto rfirst = boost::make_reverse_iterator(last); 
    return std::equal(first, m, rfirst); 
} 

Complejidad: tiempo lineal,

• Si soy RandomAccessIterator: piso (n / 2) comparaciones y piso (n / 2) * 2 iteraciones

• If I is BidirectionalIterator: piso (n / 2) comparaciones y piso (n / 2) * 2 iteraciones más (3/2) * n iteraciones para encontrar el medio (función intermedia)

• almacenamiento: O (1)

• Sin memoria asignada dymamic

Answer 7

Considerando que no hay letras en las palabras

public static boolean palindromeWords(String s ){

        int left=0;
        int right=s.length()-1;

        while(left<=right){

            while(left<right && !Character.isLetter(s.charAt(left))){
                left++;
            }
            while(right>0 && !Character.isLetter(s.charAt(right))){
                right--;
            }

            if((s.charAt(left++))!=(s.charAt(right--))){
                return false;
            }
        }
        return true;
    }

---

@Test
public void testPalindromeWords(){
    assertTrue(StringExercise.palindromeWords("ece"));
    assertTrue(StringExercise.palindromeWords("kavak"));
    assertFalse(StringExercise.palindromeWords("kavakdf"));
    assertTrue(StringExercise.palindromeWords("akka"));
    assertTrue(StringExercise.palindromeWords("??e@@c_--e"));
}

Answer 8

Estaba buscando una solución que no solo funcionara para palíndromos como ...

• "Kayac"
• "Señora"

... pero también para ...

• "¡Un hombre, un plan, un canal, Panamá!"
• "¿Fue un automóvil o un gato que vi?"
• "No ''x'' en Nixon"

Iterativo : Esto se ha demostrado como una buena solución.

private boolean isPalindromeIterative(final String string)
    {
        final char[] characters =
            string.replaceAll("[//W]", "").toLowerCase().toCharArray();

        int iteratorLeft = 0;
        int iteratorEnd = characters.length - 1;

        while (iteratorEnd > iteratorLeft)
        {
            if (characters[iteratorLeft++] != characters[iteratorEnd--])
            {
                return false;
            }
        }

        return true;
    }

Recursivo . Creo que esta solución no debería ser mucho peor que la iterativa. Es un poco lento, necesitamos extraer el paso de limpieza del método para evitar procesos innecesarios.

private boolean isPalindromeRecursive(final String string)
        {
            final String cleanString = string.replaceAll("[//W]", "").toLowerCase();
            return isPalindromeRecursiveRecursion(cleanString);
        }

private boolean isPalindromeRecursiveRecursion(final String cleanString)
        {
            final int cleanStringLength = cleanString.length();

            return cleanStringLength <= 1 || cleanString.charAt(0) ==
                       cleanString.charAt(cleanStringLength - 1) &&
                       isPalindromeRecursiveRecursion  
                           (cleanString.substring(1, cleanStringLength - 1));
        }

Inversión : esto ha demostrado ser una solución costosa.

private boolean isPalindromeReversing(final String string)
    {
        final String cleanString = string.replaceAll("[//W]", "").toLowerCase();
        return cleanString.equals(new StringBuilder(cleanString).reverse().toString());
    }

Todos los créditos a los chicos que responden en este post y que aportan luz al tema.

Answer 9

For-loop contiene sub.length() / 2 - 1 . Tiene que ser restado con 1 ya que el elemento en el medio de la cadena no tiene que marcarse.

Por ejemplo, si tenemos que marcar una cadena con 7 caracteres (1234567), luego 7/2 => 3 y luego sub-rastreamos 1, y entonces las posiciones en la cadena se convertirán en (0123456). Los caracteres que se verifican son el elemento 0, 1, 2 con el 6, 5, 4 respectivamente. No nos importa el elemento en la posición 3 ya que está en el centro exacto de la cadena.

 private boolean isPalindromic(String sub) {
        for (int i = 0; i <= sub.length() / 2 - 1; i++) {
            if (sub.charAt(i) != sub.charAt(sub.length() - 1 - i)) {
                return false;
            }
        }
        return true;
    }

Answer 10

OMI, la forma recursiva es la más simple y clara.

public static boolean isPal(String s)
{   
    if(s.length() == 0 || s.length() == 1)
        return true; 
    if(s.charAt(0) == s.charAt(s.length()-1))
       return isPal(s.substring(1, s.length()-1));                
   return false;
}

Answer 11

Otra forma es usando Char Array

public class Palindrome {

public static void main(String[] args) {
    String str = "madam";
    if(isPalindrome(str)) {
        System.out.println("Palindrome");
    } else {
        System.out.println("Not a Palindrome");
    }
}

private static boolean isPalindrome(String str) {
    // Convert String to char array
    char[] charArray = str.toCharArray();  
    for(int i=0; i < str.length(); i++) {
        if(charArray[i] != charArray[(str.length()-1) - i]) {
            return false;
        }
    }
    return true;
}

}

Answer 12

Probar esto :

import java.util.*;
    public class str {

        public static void main(String args[])
        {
          Scanner in=new Scanner(System.in);
          System.out.println("ENTER YOUR STRING: ");
          String a=in.nextLine();
          System.out.println("GIVEN STRING IS: "+a);
          StringBuffer str=new StringBuffer(a);
          StringBuffer str2=new StringBuffer(str.reverse());
          String s2=new String(str2);
          System.out.println("THE REVERSED STRING IS: "+str2);
            if(a.equals(s2))    
                System.out.println("ITS A PALINDROME");
            else
                System.out.println("ITS NOT A PALINDROME");
            }
    }

Answer 13

Puede verificar si una cadena es un palíndromo comparándola con el reverso de sí mismo:

public static boolean isPalindrome(String str) {
    return str.equals(new StringBuilder(str).reverse().toString());
}

o para versiones de Java anteriores a 1.5,

public static boolean isPalindrome(String str) {
    return str.equals(new StringBuffer().append(str).reverse().toString());
}

EDITAR: @FernandoPelliccioni proporcionó un análisis muy completo de la eficacia (o la falta de ella) de esta solución, tanto en términos de tiempo como de espacio. Si está interesado en la complejidad computacional de esta y otras posibles soluciones a esta pregunta, ¡léala!

Answer 14

Recientemente escribí un programa palindrome que no usa StringBuilder. Una respuesta tardía, pero esto podría ser útil para algunas personas.

public boolean isPalindrome(String value) {
    boolean isPalindrome = true;
    for (int i = 0 , j = value.length() - 1 ; i < j ; i ++ , j --) {
        if (value.charAt(i) != value.charAt(j)) {
            isPalindrome = false;
        }
    }
    return isPalindrome;
}

Answer 15

Soy nuevo en Java y estoy tomando su pregunta como un desafío para mejorar mi conocimiento.

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 tiene letras ni una sola 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 son diferentes, entonces 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 la respuesta para la cadena original y luego repita desde 1 .

Answer 16

Trabajé en una solución para una pregunta marcada como duplicada de esta. Bien podría tirarlo aquí ...

La pregunta solicitó una sola línea para resolver esto, y lo tomé más como el palíndromo literario, por lo que los espacios, la puntuación y la mayúscula / minúscula pueden arrojar el resultado.

Aquí está la solución fea con una pequeña clase de prueba:

public class Palindrome {
   public static boolean isPalendrome(String arg) {
         return arg.replaceAll("[^A-Za-z]", "").equalsIgnoreCase(new StringBuilder(arg).reverse().toString().replaceAll("[^A-Za-z]", ""));
   }
   public static void main(String[] args) {
      System.out.println(isPalendrome("hiya"));
      System.out.println(isPalendrome("star buttons not tub rats"));
      System.out.println(isPalendrome("stab nail at ill Italian bats!"));
      return;
   }
}

Lamento que sea algo desagradable, pero la otra pregunta especificaba un trazador de líneas.

Answer 17

Una versión concisa, que no involucra (de manera ineficiente) inicializar un grupo de objetos:

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

Answer 18

Usando la pila, se puede hacer así

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str=in.nextLine();
        str.replaceAll("//s+","");
        //System.out.println(str);
        Stack<String> stack=new Stack<String>();
        stack.push(str);
        String str_rev=stack.pop();
        if(str.equals(str_rev)){
            System.out.println("Palindrome"); 
        }else{
             System.out.println("Not Palindrome");
        }
    }
}

Answer 19

Ve, Java:

public boolean isPalindrome (String word) {
    String myWord = word.replaceAll("//s+","");
    String reverse = new StringBuffer(myWord).reverse().toString();
    return reverse.equalsIgnoreCase(myWord);
}

isPalindrome("Never Odd or Even"); // True
isPalindrome("Never Odd or Even1"); // False

Answer 20

Y aquí una solución completa de streaming de Java 8. Un IntStream proporciona todos los índices hasta cadenas de longitud y luego se realiza una comparación desde el inicio y desde el final.

public static void main(String[] args) {
    for (String testStr : Arrays.asList("testset", "none", "andna", "haah", "habh", "haaah")) {
        System.out.println("testing " + testStr + " is palindrome=" + isPalindrome(testStr));
    }
}

public static boolean isPalindrome(String str) {
    return IntStream.range(0, str.length() / 2)
            .noneMatch(i -> str.charAt(i) != str.charAt(str.length() - i - 1));
}

La salida es:

testing testset is palindrome=true
testing none is palindrome=false
testing andna is palindrome=true
testing haah is palindrome=true
testing habh is palindrome=false
testing haaah is palindrome=true

Answer 21

aquí, buscando el palíndromo más grande en una cuerda, siempre comenzando desde el 1er char.

public static String largestPalindromeInString(String in) {
    int right = in.length() - 1;
    int left = 0;
    char[] word = in.toCharArray();
    while (right > left && word[right] != word[left]) {
        right--;
    }
    int lenght = right + 1;
    while (right > left && word[right] == word[left]) {

        left++;
        right--;

    }
    if (0 >= right - left) {
        return new String(Arrays.copyOf(word, lenght ));
    } else {
        return largestPalindromeInString(
                new String(Arrays.copyOf(word, in.length() - 1)));
    }
}

Answer 22

también una solución de aspecto diferente:

public static boolean isPalindrome(String s) {

        for (int i=0 , j=s.length()-1 ; i<j ; i++ , j-- ) {

            if ( s.charAt(i) != s.charAt(j) ) {
                return false;
            }
        }

        return true;
    }

Answer 23

import java.util.Collections;
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class GetAllPalindromes 
{
    static Scanner in;

    public static void main(String[] args) 
    {
        in = new Scanner(System.in);
        System.out.println("Enter a string /n");
        String abc = in.nextLine();
        Set a = printAllPalindromes(abc);
        System.out.println("set is   " + a);
    }

    public static Set<CharSequence> printAllPalindromes(String input) 
    {
        if (input.length() <= 2) {
            return Collections.emptySet();
        }

        Set<CharSequence> out = new HashSet<CharSequence>();
        int length = input.length();

        for (int i = 1; i < length - 1; i++) 
        {
            for (int j = i - 1, k = i + 1; j >= 0 && k < length; j--, k++) 
            {
                if (input.charAt(j) == input.charAt(k)) {
                    out.add(input.subSequence(j, k + 1));
                } else {
                    break;
                }
            }
        }
        return out;
    }
}

**Get All Palindrome in s given string**

Salida D: / Java> java GetAllPalindromes Introduzca una cadena

Hola usuario nitin es mi mejor amigo ¡guau!

La respuesta está establecida es [nitin, nitin, wow, wow, iti]

D: / Java>

Answer 24

Aquí puedes consultar palindrome una cantidad de String dinámicamente

import java.util.Scanner;

public class Checkpalindrome {
 public static void main(String args[]) {
  String original, reverse = "";
  Scanner in = new Scanner(System.in);
  System.out.println("Enter How Many number of Input you want : ");
  int numOfInt = in.nextInt();
  original = in.nextLine();
do {
  if (numOfInt == 0) {
    System.out.println("Your Input Conplete");
   } 
  else {
    System.out.println("Enter a string to check palindrome");
    original = in.nextLine();

    StringBuffer buffer = new StringBuffer(original);
    reverse = buffer.reverse().toString();

  if (original.equalsIgnoreCase(reverse)) {
    System.out.println("The entered string is Palindrome:"+reverse);
   } 
  else {
    System.out.println("The entered string is not Palindrome:"+reverse);
    }
 }
   numOfInt--;
    } while (numOfInt >= 0);
}
}

Answer 25

 public static boolean isPalindrome(String word) {
    String str = "";
    for (int i=word.length()-1; i>=0;  i--){
        str = str + word.charAt(i);
    }
   if(str.equalsIgnoreCase(word)){
       return true;
   }else{
       return false;
   }

}

Answer 26

import java.util.Scanner;


public class Palindrom {

    public static void main(String []args)
    {
        Scanner in = new Scanner(System.in);
        String str= in.nextLine();
        int x= str.length();

        if(x%2!=0)
        {
            for(int i=0;i<x/2;i++)
            {

                if(str.charAt(i)==str.charAt(x-1-i))
                {
                    continue;
                }
                else 
                {
                    System.out.println("String is not a palindrom");
                    break;
                }
            }
        }
        else
        {
            for(int i=0;i<=x/2;i++)
            {
                if(str.charAt(i)==str.charAt(x-1-i))
                {
                    continue;
                }
                else 
                {
                    System.out.println("String is not a palindrom");
                    break;
                }

            }
        }
    }

}

Answer 27

private static boolean isPalindrome(String word) {

        int z = word.length();
        boolean isPalindrome = false;

        for (int i = 0; i <= word.length() / 2; i++) {
            if (word.charAt(i) == word.charAt(--z)) {
                isPalindrome = true;
            }
        }

        return isPalindrome;
    }

Answer 28

public boolean isPalindrome(String abc){
    if(abc != null && abc.length() > 0){
        char[] arr = abc.toCharArray();
        for (int i = 0; i < arr.length/2; i++) {
            if(arr[i] != arr[arr.length - 1 - i]){
                return false;
            }
        }
        return true;
    }
    return false;
}

Answer 29

public class Aufg1 {
    public static void main(String[] args) {
         String wort = "reliefpfpfeiller";
         char[] warray = wort.toCharArray(); 
         System.out.println(istPalindrom(warray));       
    }

    public static boolean istPalindrom(char[] wort){
        if(wort.length%2 == 0){
            for(int i = 0; i < wort.length/2-1; i++){
                if(wort[i] != wort[wort.length-i-1]){
                    return false;
                }
            }
        }else{
            for(int i = 0; i < (wort.length-1)/2-1; i++){
                if(wort[i] != wort[wort.length-i-1]){
                    return false;
                }
            }
        }
        return true;
    }
}

Answer 30

public class palindrome {
public static void main(String[] args) {
    StringBuffer strBuf1 = new StringBuffer("malayalam");
    StringBuffer strBuf2 = new StringBuffer("malayalam");
    strBuf2.reverse();


    System.out.println(strBuf2);
    System.out.println((strBuf1.toString()).equals(strBuf2.toString()));
    if ((strBuf1.toString()).equals(strBuf2.toString()))
        System.out.println("palindrome");
    else
        System.out.println("not a palindrome");
}

}