Vérifiez si une chaîne en JavaScript peut être un palindrome

Explorer le monde de la manipulation de chaînes en JavaScript révèle un défi fascinant : déterminer si une chaîne donnée peut être convertie en palindrome. Les palindromes, où le même mot ou la même phrase est lu recto verso, ont un attrait inhérent et suscitent la curiosité des développeurs cherchant à découvrir leurs propriétés mystérieuses. Dans cet article, nous nous lancerons dans un voyage éclairant pour découvrir les complexités de la vérification si une chaîne peut se transformer en palindrome à l'aide des puissantes fonctionnalités de langage et des algorithmes inhérents à JavaScript. En nous plongeant dans la manipulation des chaînes et en employant des techniques innovantes, nous perçons le mystère de la conversion des chaînes en palindromes, améliorant ainsi nos compétences en tant que praticiens avertis de JavaScript.

Énoncé du problème

La tâche actuelle consiste à développer un algorithme JavaScript capable de déterminer efficacement si une chaîne donnée peut être convertie en palindrome en supprimant un seul caractère. Les palindromes restent inchangés lors de la lecture vers l'avant ou vers l'arrière. L'algorithme nécessite une analyse approfondie de la chaîne d'entrée, en examinant ses caractères individuels tout en envisageant la possibilité de supprimer des caractères individuels si un palindrome doit être créé. La sortie sera un booléen indiquant si la chaîne peut être convertie en palindrome. Pour une meilleure compréhension, considérons l’exemple suivant.

Exemple de saisie

"racecar"

Exemple de sortie

true

indique que la chaîne peut effectivement être convertie en palindrome en supprimant au plus un caractère.

Méthode

Dans cet article, nous verrons différentes manières de résoudre les problèmes ci-dessus en JavaScript -

• Doubles mains

• Récursion

• Planification dynamique

Méthode 1 : Deux pointeurs

Le problème courant de vérifier si une chaîne peut être un palindrome en JavaScript peut être résolu en utilisant la méthode à deux pointeurs. Cela implique d'initialiser deux pointeurs, un au début de la chaîne et un à la fin de la chaîne, de comparer les caractères au niveau de ces pointeurs et de les déplacer vers le centre. Pour y parvenir, définissez une fonction JavaScript qui prend une chaîne en entrée, initialise les pointeurs et modifie les variables. Ensuite, utilisez une boucle while pour comparer les caractères, ajouter des modifications sans correspondance et déplacer le pointeur en conséquence. Une fois la boucle terminée, vérifiez si les modifications sont inférieures ou égales à 1 pour déterminer si un palindrome peut être formé. Enfin, une valeur booléenne est renvoyée indiquant si un palindrome peut être créé à partir de la chaîne.

Exemple

La fonction

canBePalindrome vérifie si une chaîne peut devenir un palindrome en supprimant au plus un caractère. Il utilise une approche à deux pointeurs pour parcourir la chaîne et comparer les caractères. Si les caractères sont égaux, les deux pointeurs se déplacent vers le centre. Sinon, il vérifie si un caractère peut être supprimé en comparant les caractères adjacents. Renvoie false si un caractère a été supprimé. Si la boucle se termine sans renvoyer false, renvoie true, indiquant que la chaîne peut devenir un palindrome. L'exemple d'utilisation en bas démontre cette fonctionnalité.

function canBePalindrome(str) {
   let left = 0;
   let right = str.length - 1;
   let removed = false;
 
   while (left < right) {
      if (str[left] !== str[right]) {
         if (removed) {
            return false; // Already removed a character, can't remove more
         }
         
         // Try removing either the character at the left or right pointer
         if (str[left + 1] === str[right]) {
            left++;
         } else if (str[left] === str[right - 1]) {
            right--;
         } else {
            return false; // Unable to make the string a palindrome by removing one character
         }
      
         removed = true;
      }   
      left++;
      right--;
   }
   return true; // The string can be made a palindrome by removing at most one character
}
 
// Example usage:
console.log(canBePalindrome("racecar")); // true
console.log(canBePalindrome("abccdba")); // true
console.log(canBePalindrome("abccba")); // true
console.log(canBePalindrome("abcdcba")); // true
console.log(canBePalindrome("abcddba")); // false
console.log(canBePalindrome("abcdefg")); // false

Sortie

Ce qui suit est la sortie de la console -

true
true
true
true
true
false

Méthode 2 : Récursivité

Pour vérifier si vous pouvez faire d'une chaîne un palindrome en utilisant la récursivité en JavaScript, définissez une fonction appelée canBePalindrome() qui accepte une chaîne d'entrée. Pour le cas de base, renvoie true si la longueur de la chaîne est inférieure ou égale à 1. Sinon, comparez le premier et le dernier caractères et appelez canBePalindrome() de manière récursive avec la chaîne mise à jour, en supprimant les caractères s'ils sont égaux. Ce processus est répété jusqu'à ce que le cas de base soit atteint. Renvoie false si le premier et le dernier caractères ne sont pas égaux. Enfin, canBePalindrome() est appelé avec la chaîne d'entrée, stocke le résultat et poursuit le traitement ou affiche un message approprié en fonction du résultat.

Exemple

Dans ce code, la fonction canFormPalindrome accepte une chaîne en entrée et renvoie vrai si la chaîne peut devenir un palindrome en supprimant au plus un caractère, sinon elle renvoie faux. La fonction isPalindrome est une fonction d'assistance qui vérifie si une sous-chaîne est un palindrome.

function canFormPalindrome(str) {
   // Helper function to check if a substring is a palindrome
   function isPalindrome(left, right) {
      while (left < right) {
         if (str[left] !== str[right]) {
            return false;
         }
         left++;
         right--;
      }
      return true;
   }
 
   // Recursive function to check if the string can be made a palindrome
   function checkPalindrome(left, right) {
      if (left >= right) {
         return true; // Base case: single character or empty string
      }
 
      if (str[left] === str[right]) {
         return checkPalindrome(left + 1, right - 1); // Characters match, check inner substring
      }
 
      // Try removing either left or right character and check the remaining substring
      return isPalindrome(left + 1, right) || isPalindrome(left, right - 1);
   }
 
   // Call the recursive function starting from the endpoints of the string
   return checkPalindrome(0, str.length - 1);
}
 
// Example usage
console.log(canFormPalindrome("abcba")); // true
console.log(canFormPalindrome("abbca")); // true
console.log(canFormPalindrome("abcd")); // false

Sortie

Ce qui suit est la sortie de la console -

true
true
false

Méthode 3 : Programmation dynamique

Pour vérifier si vous pouvez convertir une chaîne en palindrome à l'aide de la programmation dynamique en JavaScript, définissez une fonction appelée canBePalindrome qui prend une chaîne en entrée. Créez une table de programmation dynamique pour stocker les résultats des sous-problèmes. Parcourez la chaîne à partir des deux extrémités à l'aide de deux pointeurs, en comparant les caractères à ces positions. S'ils sont identiques, déplacez le pointeur en conséquence. Si différent, vérifiez si la sous-chaîne entre les pointeurs a été traitée dans le tableau. Dans le cas contraire, la fonction canBePalindrome est appelée de manière récursive sur la sous-chaîne et le résultat est stocké. Pensez à exclure les caractères des pointeurs gauche et droit et mettez à jour le tableau si l'un ou l'autre cas renvoie vrai. Après avoir mis à jour la table, renvoyez la valeur stockée dans l'entrée qui représente la chaîne entière pour déterminer si elle peut être réorganisée en palindrome. Cette approche résout les problèmes efficacement en tirant parti de la programmation dynamique et en la décomposant en sous-problèmes.

示例

在此代码中，canFormPalindrome 函数将字符串 str 作为输入，并返回一个布尔值，指示该字符串是否可以通过最多删除一个字符来使该字符串成为回文。该函数使用动态规划表dp来存储中间结果并检查str的所有可能的子串。最后，如果整个字符串可以成为回文，则返回 true，否则返回 false。

function canFormPalindrome(str) {
   const n = str.length;
 
   // Create a 2D dynamic programming table
   const dp = Array(n)
   .fill(false)
   .map(() => Array(n).fill(false));
 
   // Initialize the diagonal to true
   for (let i = 0; i < n; i++) {
      dp[i][i] = true;
   }
 
   // Fill the table diagonally
   for (let len = 2; len <= n; len++) {
      for (let i = 0; i < n - len + 1; i++) {
         const j = i + len - 1;
    
         if (str[i] === str[j]) {
         
            // Characters at the current indices are equal
            dp[i][j] = dp[i + 1][j - 1];
         } else {
         
            // Try removing either the character at index i or j
            dp[i][j] = dp[i + 1][j] || dp[i][j - 1];
         }
      }
   }
 
   // Return true if the whole string can be made a palindrome by removing at most one character
   return dp[0][n - 1];
}
 
// Example usage:
const str = "abca";
const canBePalindrome = canFormPalindrome(str);
console.log(canBePalindrome); 

输出

以下是控制台输出 -

true

结论

总之，确定字符串是否可以使用 JavaScript 转换为回文的过程是一个多方面的工作。通过利用各种字符串操作技术并采用系统方法，人们可以有效地确定实现回文对称的可行性。对字符频率的细致评估以及不常见字符串算法的利用可以带来令人着迷的见解和创造性的解决方案。从事这种智力追求使程序员能够深入研究语言操作的复杂性，从而对语言领域进行令人满意的探索。最终，识别字符串中回文潜力的能力证明了 JavaScript 作为编程语言的独创性和多功能性。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!