Questions essentielles sur l'algorithme JavaScript pour la pratique

Que vous vous prépariez pour un entretien de codage ou que vous cherchiez à perfectionner vos compétences en résolution de problèmes, la pratique des algorithmes est essentielle pour maîtriser JavaScript. Les algorithmes ne sont pas réservés aux développeurs avancés : ils sont fondamentaux pour comprendre comment manipuler les données et optimiser les performances de vos applications.

Dans cet article, nous explorerons quelques questions essentielles sur les algorithmes JavaScript que tout développeur devrait mettre en pratique. Ces questions couvrent une gamme de sujets, de la manipulation de base des tableaux à la gestion des chaînes plus complexes, vous donnant une base solide pour aborder des problèmes plus avancés.

---

1. Inverser une chaîne

Problème :
Écrivez une fonction qui prend une chaîne en entrée et renvoie la chaîne inversée.

Exemple :

// Input: "hello"
// Output: "olleh"

Solution :
Il existe plusieurs façons d'inverser une chaîne en JavaScript. L'une des méthodes les plus simples consiste à diviser la chaîne en un tableau de caractères, à inverser le tableau, puis à le réunir à nouveau en une chaîne.

function reverseString(str) {
  return str.split('').reverse().join('');
}

console.log(reverseString("hello")); // Output: "olleh"

2. Recherchez les palindromes

Problème :
Un palindrome est un mot ou une phrase qui se lit de la même manière vers l'arrière et vers l'avant. Écrivez une fonction pour vérifier si une chaîne donnée est un palindrome.

Exemple :

// Input: "racecar"
// Output: true

// Input: "hello"
// Output: false

Solution :
Vous pouvez réutiliser la méthode d'inversion de chaîne pour vérifier si la chaîne d'origine est égale à son inverse.

function isPalindrome(str) {
  const reversedStr = str.split('').reverse().join('');
  return str === reversedStr;
}

console.log(isPalindrome("racecar")); // Output: true
console.log(isPalindrome("hello"));   // Output: false

3. Trouver le plus grand nombre dans un tableau

Problème :
Écrivez une fonction qui prend un tableau de nombres en entrée et renvoie le plus grand nombre.

Exemple :

// Input: [1, 2, 3, 4, 5]
// Output: 5

Solution :
Vous pouvez utiliser la méthode Math.max en combinaison avec l'opérateur spread pour trouver le plus grand nombre.

function findLargest(arr) {
  return Math.max(...arr);
}

console.log(findLargest([1, 2, 3, 4, 5])); // Output: 5

4. FizzBuzz

Problème :
Écrivez une fonction qui imprime les nombres de 1 à 100. Mais pour les multiples de trois, imprimez « Fizz » au lieu du nombre, et pour les multiples de cinq, imprimez « Buzz ». Pour les nombres multiples de trois et cinq, imprimez « FizzBuzz ».

Solution :
Il s'agit d'une question d'entretien classique qui teste votre capacité à implémenter des boucles et des conditions de base.

function fizzBuzz() {
  for (let i = 1; i <= 100; i++) {
    if (i % 3 === 0 && i % 5 === 0) {
      console.log("FizzBuzz");
    } else if (i % 3 === 0) {
      console.log("Fizz");
    } else if (i % 5 === 0) {
      console.log("Buzz");
    } else {
      console.log(i);
    }
  }
}

fizzBuzz();

5. Factorialiser un nombre

Problème :
Écrivez une fonction qui renvoie la factorielle d'un nombre. La factorielle d'un nombre n est le produit de tous les entiers positifs inférieurs ou égaux à n.

Exemple :

// Input: 5
// Output: 120 (5 * 4 * 3 * 2 * 1)

Solution :
Les factorielles peuvent être résolues de manière récursive ou itérative. Voici un exemple utilisant la récursion :

function factorialize(num) {
  if (num === 0 || num === 1) {
    return 1;
  } else {
    return num * factorialize(num - 1);
  }
}

console.log(factorialize(5)); // Output: 120

6. Trouver le mot le plus long dans une chaîne

Problème :
Écrivez une fonction qui prend une chaîne en entrée et renvoie la longueur du mot le plus long.

Exemple :

// Input: "The quick brown fox jumped over the lazy dog"
// Output: 6 (jumped)

Solution :
Vous pouvez diviser la chaîne en un tableau de mots, puis réduire le tableau pour trouver le mot le plus long.

function findLongestWord(str) {
  const words = str.split(' ');
  let maxLength = 0;

  for (let word of words) {
    if (word.length > maxLength) {
      maxLength = word.length;
    }
  }

  return maxLength;
}

console.log(findLongestWord("The quick brown fox jumped over the lazy dog")); // Output: 6

7. Supprimer les doublons d'un tableau

Problème :
Écrivez une fonction qui supprime les valeurs en double d'un tableau.

Exemple :

// Input: [1, 2, 2, 3, 4, 4, 5]
// Output: [1, 2, 3, 4, 5]

Solution :
L'un des moyens les plus simples de supprimer les doublons consiste à utiliser un ensemble, qui stocke uniquement des valeurs uniques.

function removeDuplicates(arr) {
  return [...new Set(arr)];
}

console.log(removeDuplicates([1, 2, 2, 3, 4, 4, 5])); // Output: [1, 2, 3, 4, 5]

Conclusion

La pratique de ces questions fondamentales sur l'algorithme JavaScript améliorera vos compétences en résolution de problèmes et vous préparera à des défis plus avancés. En maîtrisant ces bases, vous serez mieux équipé pour aborder des algorithmes et des structures de données complexes, essentiels à l'écriture d'un code efficace et évolutif. Continuez à vous entraîner et vous constaterez des améliorations dans votre vitesse et votre précision de codage !

Bon codage ?‍?

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!