Bonsoir voulant m’entraîner à l'algo je fais des exercices mais la je bloque depuis un moment ... si vous pouviez me donner une piste ?

voici l'énoncé :

Écrivez une fonction nommée first_non_repeating_letter qui prend une entrée de chaîne et renvoie le premier caractère qui n'est répété nulle part dans la chaîne.

function firstNonRepeatingLetter(s) {
let saveRepetition = []
let comparaison = 0 
let suivant = 0
let i = 0

if (s.length <= 1) {
    return s
}
  while (s[i]){ 
      comparaison = 0
      suivant = i + 1
      while (s[suivant]) {
          if (s[i] === s[suivant]) {
              comparaison++
          }
          suivant++
      }
      if (comparaison >= 1) {
          saveRepetition = saveRepetition + s[i]
          console.log(save) 
         
      } else if (comparaison === 0) {
          suivant = 0
          while(saveRepetition[suivant]) {
              if (saveRepetition[suivant] === s[i]) {
                  comparaison++ 
              }
              suivant++
          }
          if (comparaison === 0) {
              return s[i]
          }
      } 
      i++
  }
  return ""
}

-
Edité par Elyakim 21 janvier 2020 à 10:42:10

Salut,

Tu dois réaliser tes comparaisons de lettre avec uniquement des majuscules ou uniquement des minuscules. Donc utilise 'toLowerCase()' ou 'toUpperCase()' :

function firstNonRepeatingLetter(s) {
let saveRepetition = []
let comparaison = 0
let suivant = 0
let i = 0
 
if (s.length <= 1) {
    return s
}
  while (s[i]){
      comparaison = 0
      suivant = i + 1
      while (s[suivant]) {
          if (s[i].toLowerCase() === s[suivant].toLowerCase()) {
              comparaison++
          }
          suivant++
      }
      if (comparaison >= 1) {
          saveRepetition = saveRepetition + s[i]
          
      } else if (comparaison === 0) {
          suivant = 0
          while(saveRepetition[suivant]) {
              if (saveRepetition[suivant].toLowerCase() === s[i].toLowerCase()) {
                  comparaison++
              }
              suivant++
          }
          if (comparaison === 0) {
              return s[i]
          }
      }
      i++
  }
  return ""
}

Je te propose également cette méthode qui est plus explicite (à mon sens) :

const first_non_repeating_letter = function(str) {
    const arr1 = str.split(''); // Obtenir un array à partir de str.
    const arr2 = str.toLowerCase().split(''); // Obtenir un second array à partir de str, mais ne contenant que des minuscules.
    return arr1.find((x, i) => { // Rechercher et renvoyer la première entrée de arr1 respectant la condition issue de la fonction anonyme suivante :
        const arr3 = arr2.slice(); // Obtenir une copie superficielle de arr2 dans arr3 pour éviter d'altérer arr2 par la suite.
        arr3.splice(i, 1); // Supprimer la lettre à la position i de l'arr3.
        return !arr3.some(y => x.toLowerCase() === y); // Retourner False si arr3 contient toujours au moins une fois la lettre qui vient d'être supprimer (qu'elle soit majuscule ou minuscule), retourner True si non.
    });
};

Documentation :

• String.prototype.split() : pour obtenir un Array à partir d'un String.
• String.prototype.toLowerCase() : pour transformer tout les caractères majuscule d'un String en leurs équivalent minuscule.
• Array.prototype.find() : pour trouver la première occurrence respectant une condition parmi les entrées d'un Array et la renvoyer.
• Array.prototype.slice() : pour obtenir une copie superficielle d'une partie ou de la totalité d'un Array.
• Array.prototype.splice() : pour modifier un Array (supprimer une entrée dans ce cas-ci).
• Array.prototype.some() : pour vérifier l’existence d'un élément dans un Array (renvoi True si au moins une entrée dans l'Array respecte une condition)

Utilise des point-vigules pour terminer tes instructions.

-
Edité par BrainError 21 janvier 2020 à 13:53:17

Toutes les fonctions que j'ai employé dans mon exemple sont des fonctions de base de javascript et tu peux tout à fait les utiliser.
Tu peux directement tester la fonction first_non_repeating_letter sur une console chrome par exemple pour t'en rendre compte.

Pour ce qui est de Splice, la fonction renvoie les éléments qui ont été supprimé ET modifie l'Array qui à servi de contexte.
Ainsi si tu as :

const arr1 = ['T', 'e', 's', 't'];

et que tu utilise l'instruction :

const arr2 = arr1.splice(1, 1);

alors arr1 sera égal à "['T', 's', 't']" et arr2 sera égal à "['e']".

Quand je l'emploi la console met une erreur en disant que ce n'est pas une fonction je vais réessayer alors, tu t'y connais mieux que moi ! :) 

Bonjour,

une autre solutions serait de passer par une regexp comme ceci:

const FNRL= function(str) { //First Non Repeating Letter
    //On duplique la chaine de caractère dans une autre variable
    //Et on la "transforme" en Array avec String.prototype.split()
    let lettres= str.split('');
    //On boucle tant que l'array n'est pas vite
    while(lettres.length>0) {
        //On récupére la première lettre, et on la supprime du tableau
        //Avec Array.prototype.shift()
        let lettre = lettres.shift(),
            //On construit la RegExp avec le constructeur RegExp
            regexp = new RegExp(lettre, 'gi'),
            //On utilise String.prototype.matchAll() pour récupéré
            //tout les lettres correspondante.
            //Et transforme l'itérateur en Array avec [... Iterateur]
            //J'utilise le paramètres du reste pour avoir une syntaxe
            //plus courte parce que les explications prennent beaucoup
            //trop de place >.> mais tu peut faire la conversion autrement.
            resultat = [...str.matchAll(regexp)];
        //On vérifie si notre tableau contient moins de 2 resultat si
        //c'est le cas, ça signifie que la lettre est unique.
        if(resultat.length<2) {
            //On force la fin de la boucle avec return. (puisque le
            //reste ne nous interesse pas).
            //et ont renvoie la lettre qui a matcher (lettre).
            return lettre; 
        }
    } return false; //On renvoie false si aucune lettre n'est unique
};

console.log(FNRL('sTreSS')); //Affiche "T"

Si les commentaires te rebute un peu, sache que sans les commentaire le code ressemble à ça : 

const FNRL= function(str) {
    let lettres= str.split('');
    while(lettres.length>0) {
        let lettre = lettres.shift(),
            regexp = new RegExp(lettre, 'gi'),
            resultat = [...str.matchAll(regexp)];
        if(resultat.length<2) {
            return lettre; 
        }
    } return false;
};
console.log(FNRL('sTreSS'));

Maintenant place au lien utile (parce que j'explique ce que je fait mais pas comment ça marche :p) :

 - J'utilise une constante pour déclarer ma fonction, et a l'intérieur j'utilise des variables à faible portée let.
 - J'utilise la méthode split()
 - J'utilise la méthode shift().
 - J'utilise le constructeur RegExp().
 - J'utilise la méthode matchAll() en combinaison avec le paramètre du reste.

Bonne lecture

Çà y est j'ai réussi, il était tard quand j'essayais d'utiliser les fonction de base j'ai du faire n'importe quoi, merci a toi. Par contre je l'ai plus fais a ma façon car ta solution m'est moins évidente, ma logique était elle mauvaise ? Je vais et j'ai un peu de mal avec les fonctions fléchés, je vais regarder la doc que tu m'as donner et essayer de tout comprendre à ta manière de faire ! Merci beaucoup a toi ! 

EDIT : Quand je vois les solutions de certains ... problème réglé en une ligne ... et effectivement certains on utilisé un RegExp je vais aussi pencher la dessus, merci a vous deux ! 

-
Edité par Elyakim 21 janvier 2020 à 12:49:00