Vérifier le palindrome d'une chaîne de caractères

Question

A palindrome est un mot, une phrase, un nombre ou une autre séquence d'unités qui peut être lu de la même façon dans les deux sens.

Pour vérifier si un mot est un palindrome, je récupère le tableau de caractères du mot et je compare les caractères. Je l'ai testé et cela semble fonctionner. Cependant, je voudrais savoir si c'est correct ou s'il y a quelque chose à améliorer.

Voici mon code :

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

Voici mon analyse de la réponse de @Greg : componentsprogramming.com/palindromes

---

Sidenote : Mais, pour moi, il est important de le faire d'une manière Voie générique . Les exigences sont que la séquence soit itérable de manière bidirectionnelle et que les éléments de la séquence soient comparables par égalité. Je ne sais pas comment le faire en Java, mais voici une version C++, je ne connais pas de meilleure façon de le faire pour les séquences bidirectionnelles.

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

Complexité : temps linéaire,

• Si I est RandomAccessIterator : comparaisons de floor(n/2) et itérations de floor(n/2)*2

• Si I est BidirectionalIterator : comparaisons de floor(n/2) et itérations de floor(n/2)*2 plus (3/2)*n itérations pour trouver le milieu (fonction milieu)

• stockage : O(1)

• Aucune mémoire dymamique allouée

---

Answer 2

Récemment, j'ai écrit un programme palindrome qui n'utilise pas StringBuilder. Une réponse tardive mais cela pourrait être utile à certaines personnes.

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 3

En utilisant la pile, cela peut être fait comme suit

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 4

 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 5

• Cette mise en œuvre fonctionne pour les nombres et les chaînes de caractères.
• Puisque nous n'écrivons rien, il n'est pas nécessaire de convertir la chaîne en tableau de caractères.

public static boolean isPalindrome(Object obj)
{
    String s = String.valueOf(obj);

    for(int left=0, right=s.length()-1; left < right; left++,right--)
    {
        if(s.charAt(left++) != s.charAt(right--))
            return false;
    }
    return true;
}