TOC

Vérifier si une chaîne est un palindrome

Vérifier si une chaîne est un palindrome

1. introduction

Dans cet article, nous allons voir comment nous pouvons vérifier si unString donné est un palindrome utilisant Java.

A palindrome is a word, phrase, number, or other sequences of characters which reads the same backward as forward, comme «madame» ou «racecar».

2. Solutions

Dans les sections suivantes, nous examinerons les différentes façons de vérifier si unString donné est un palindrome ou non.

2.1. Une approche simple

Nous pouvons simultanément commencer à itérer lesstring donnés en avant et en arrière, un caractère à la fois. S'il y a correspondance, la boucle continue. sinon, la boucle se termine: 

public boolean isPalindrome(String text) {
    String clean = text.replaceAll("\\s+", "").toLowerCase();
    int length = clean.length();
    int forward = 0;
    int backward = length - 1;
    while (backward > forward) {
        char forwardChar = clean.charAt(forward++);
        char backwardChar = clean.charAt(backward--);
        if (forwardChar != backwardChar)
            return false;
    }
    return true;
}

2.2. Inverser la chaîne

Il y a quelques implémentations différentes qui correspondent à ce cas d'utilisation: nous pouvons utiliser les méthodes API des classesStringBuilder etStringBuffer lors de la vérification des palindromes, ou nous pouvons inverser lesString sans celles-ci Des classes.

Examinons d'abord les implémentations de code sans les API d'assistance: 

public boolean isPalindromeReverseTheString(String text) {
    StringBuilder reverse = new StringBuilder();
    String clean = text.replaceAll("\\s+", "").toLowerCase();
    char[] plain = clean.toCharArray();
    for (int i = plain.length - 1; i >= 0; i--) {
        reverse.append(plain[i]);
    }
    return (reverse.toString()).equals(clean);
}

Dans l'extrait de code ci-dessus, nous itérons simplement lesString donnés du dernier caractère et ajoutons chaque caractère au caractère suivant, jusqu'au premier caractère, inversant ainsi lesString. donnés

Enfin, nous testons l'égalité entre lesString donnés et lesString. inversés

Le même comportement pourrait être obtenu à l'aide de méthodes API.

Voyons une rapide démonstration: 

public boolean isPalindromeUsingStringBuilder(String text) {
    String clean = text.replaceAll("\\s+", "").toLowerCase();
    StringBuilder plain = new StringBuilder(clean);
    StringBuilder reverse = plain.reverse();
    return (reverse.toString()).equals(clean);
}

public boolean isPalindromeUsingStringBuffer(String text) {
    String clean = text.replaceAll("\\s+", "").toLowerCase();
    StringBuffer plain = new StringBuffer(clean);
    StringBuffer reverse = plain.reverse();
    return (reverse.toString()).equals(clean);
}

Dans l'extrait de code, nous appelons la méthodereverse() à partir des APIStringBuilder etStringBuffer pour inverser lesString donnés et tester l'égalité.

2.3. Utilisation de l'APIStream

Nous pouvons également utiliser unIntStream pour fournir une solution: 

public boolean isPalindromeUsingIntStream(String text) {
    String temp  = text.replaceAll("\\s+", "").toLowerCase();
    return IntStream.range(0, temp.length() / 2)
      .noneMatch(i -> temp.charAt(i) != temp.charAt(temp.length() - i - 1));
}

Dans l'extrait ci-dessus, nous vérifions qu'aucune des paires de caractères de chaque extrémité duString ne remplit la conditionPredicate.

2.4. Utilisation de la récursivité

La récursivité est une méthode très populaire pour résoudre ce type de problèmes. Dans l'exemple démontré, nous itérons récursivement lesString donnés et testons pour savoir s'il s'agit d'un palindrome ou non: 

public boolean isPalindromeRecursive(String text){
    String clean = text.replaceAll("\\s+", "").toLowerCase();
    return recursivePalindrome(clean,0,clean.length()-1);
}

private boolean recursivePalindrome(String text, int forward, int backward) {
    if (forward == backward) {
        return true;
    }
    if ((text.charAt(forward)) != (text.charAt(backward))) {
        return false;
    }
    if (forward < backward + 1) {
        return recursivePalindrome(text, forward + 1, backward - 1);
    }

    return true;
}

3. Conclusion

Dans ce rapide tutoriel, nous avons vu comment savoir si unString donné est un palindrome ou non.

Comme toujours, les exemples de code pour cet article sont disponiblesover on GitHub.

Related