Comment compter les caractères communs à deux chaînes de caractères en JavaScript ?

Question

Étant donné deux chaînes de caractères  s1  y  s2  composé d'alphabets anglais minuscules, la tâche consiste à compter toutes les paires d'indices ( i, j ) à partir des chaînes de caractères données, de sorte que  s1[i] = s2[j]  et tous les indices sont distincts, c'est-à-dire si  s1[i]  paires avec certains  s2[j]  alors ces deux personnages ne seront pas associés à un autre personnage.

Input: s1 = 'abcd', s2 = 'aad'
Output: 2

Input: s1 = 'geeksforgeeks', s2 = 'platformforgeeks'
Output: 8

J'ai essayé d'aimer ça :

function getSameCount(str, str2) {
  var o = {},
    o2 = {};
  for (var i = 0; i < str.length - 1; i++) {
    if (str[i] in o) {
      o[str[i]] = parseInt(o[str[i]] + 1)
    } else {
      o[str[i]] = 0
    }
  }
  console.log(o);

  for (var i = 0; i < str2.length - 1; i++) {
    if (str[i] in o2) {
      o2[str[i]] = parseInt(o2[str[i]] + 1)
    } else {
      o2[str[i]] = 0
    }
  }

  console.log(o2);
}

getSameCount('abcd', 'aad')

Answer 1

Utilisez for..in boucle et includes méthode

var s1 = "abcd";
var s2 = "aad";
var count=0;
function match(s1,s2)
{
for(let i in s1)
s2.includes(s1[i])?count++:false;
console.log(count)
}
match(s1,s2)

Answer 2

Nous pouvons convertir la deuxième chaîne d'entrée en un tableau, puis l'étape suivante consiste à itérer sur la première chaîne d'entrée et à trouver une correspondance dans le tableau de caractères de la deuxième chaîne d'entrée.

Si une correspondance est trouvée, incrémentez le compteur et supprimez ce caractère du tableau de caractères de la deuxième chaîne d'entrée afin qu'il ne soit pas pris en compte dans la correspondance suivante :

//Solution:
function getSameCount(str1, str2) {
  let count = 0;
  const obj = str2.split("");
  for(str of str1){
    let idx = obj.findIndex(s => s === str);
    if(idx >= 0){
      count++;
      obj.splice(idx, 1);
    }
  }
  return count;
}

//Test:
console.log(getSameCount("abcd", "aad"));
console.log(getSameCount("geeksforgeeks", "platformforgeeks"));
console.log(getSameCount("aad", "abcd"));
console.log(getSameCount("platformforgeeks", "geeksforgeeks"));

Answer 3

Essayez ce code :

function countMatch(s1,s2){
    var count = 0;
    while(s1.length && s2.length){
        if(s2.includes(s1.charAt(0))){
            count++;
            s2 = s2.replace(s1.charAt(0),"");
            s1 = s1.slice(1);
        }
        else {
            s1 = s1.slice(1);
        }
    }
    return count;
}

console.log(countMatch("abcd","aad"));
//2

Answer 4

Vous pouvez créer une méthode personnalisée sur le tableau et trouver le nombre de caractères qui sont communs à tous les mots. Les étapes ci-dessous sont une liste de procédures pour trouver les caractères communs dans toutes les chaînes de caractères.

1. Créer une méthode prototype sur Array , findCommonWord dans ce cas.

2. Cette méthode accepte un tableau de chaînes, donc l'entrée sera comme suit

   [ "abcd", "aad","geeksforgeeksda","platdformforgeeks"].findCommonWord()

3. La première étape consiste à modifier l'entrée, pour supprimer les caractères en double d'une chaîne en utilisant Set puis sort par ordre croissant de la length de la ficelle. En effet, le nombre de boucles sera moindre si nous devons trouver un caractère commun, qui doit également être présent dans la chaîne avec la plus petite longueur.

4. Ensuite, créez un nouveau tableau sans la première chaîne et divisez la première chaîne. split créera un nouveau tableau et le parcourra pour vérifier si ce caractère est présent dans le reste de la chaîne.

   var s1 = "abcd", s2 = "aad", s3 = "geeksforgeeksda", s4 = "platdformforgeeks";

   Array.prototype.findCommonWord = function() { let tempArray = this.map(function(item) { return [...new Set(item.split(''))].join(''); }).sort(function(a, b) { return a.length - b.length })

   let count = 0; let firstElm = tempArray[0].split(''); let restElem = tempArray.splice(1); let countObject = {}

   for (let i = 0; i < firstElm.length; i++) { let z = findIfIncludes(restElem, firstElm[i]); if (z.length === restElem.length) { countObject[firstElm[i]] = 1; } else { countObject[firstElm[i]] = 0 } }

   function findIfIncludes(arr, char) { return arr.filter(item => item.includes(char)) } console.log(countObject) let totalCount = 0; for (let keys in countObject) { if (countObject[keys] > 0) { totalCount += 1; } } return totalCount; }; console.log([s1, s2, s3, s4].findCommonWord());

Answer 5

J'ai utilisé des objets pour ce faire, et j'étais un peu curieux de savoir s'il existait un autre moyen, car je voulais aussi adopter une approche algorithmique, mais ce qui fonctionne fonctionne fonctionne.

Quoi qu'il en soit, voici le code :

function commonCharacterCount(s1, s2) {
  let string1Counter = {};
  let string2Counter = {};
  let commonCount = 0;
  for(let i = 0; i < s1.length; i++){
      if(!string1Counter.hasOwnProperty(s1[i])){
        string1Counter[s1[i]] = 0; 
      }
      string1Counter[s1[i]]++;
  }
  for(let i = 0; i < s2.length; i++){
      if(!string2Counter.hasOwnProperty(s2[i])){
        string2Counter[s2[i]] = 0; 
      }
      string2Counter[s2[i]]++;
  }
  for(let key in string1Counter){
     if(string2Counter.hasOwnProperty(key)){
       if(string1Counter[key] < string2Counter[key]){
           commonCount += string1Counter[key];
       }
       else{
           commonCount += string2Counter[key];
       }
     }
  }
  return commonCount;
}

La logique consiste essentiellement à enregistrer tous les caractères de chaque chaîne et leur nombre, à vérifier les similitudes et à comparer le nombre de caractères communs. La chaîne qui a le moins de caractères communs sera la chaîne partagée par les deux.

Complexité en temps O(3N), complexité en espace O(2N) (à cause des objets stockés). Je suppose que je peux aussi faire "delete object" mais cela semble redondant sur un simple algorithme IDE car ce n'est pas comme s'il tournait sur un serveur pendant une période prolongée.