Question

给出两个由小写英文字母组成的字符串s1和s2，任务是对给定字符串中的所有索引对（i，j）进行计数，使得s1 [i] = s2 [j]，所有索引均为不同的，即如果s1 [i]与某些s2 [j]配对，则这两个字符将不会与任何其他字符配对。

Input: s1 = “abcd”, s2 = “aad”
Output: 2

Input: s1 = “geeksforgeeks”, s2 = “platformforgeeks”
Output: 8

我尝试过

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

使用for..in循环和includes方法

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

我们可以将第二个输入字符串转换为数组，然后下一步是遍历第一个输入字符串并在第二个输入字符串的字符数组中找到匹配项。

如果找到匹配项，则增加计数器并从第二个输入字符串的字符数组中删除该字符，以便在下一个匹配项中不考虑该字符：

//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

尝试以下代码：

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

您可以在数组上创建一个自定义方法，并找到所有单词中共有的字符数。以下步骤是在所有字符串中查找公用字符的过程列表

在这种情况下，在Array，findCommonWord上创建原型方法。
此方法接受字符串数组，因此输入将类似于

[ "abcd", "aad","geeksforgeeksda","platdformforgeeks"].findCommonWord()
第一步是修改输入，使用Set，然后按sort字符串的升序，length从字符串中删除重复的字符。这是因为如果我们必须找到共同的字符，那么循环的次数将最少，该字符也必须以最小长度的字符串出现。
然后创建一个没有第一个字符串的新数组，并分割第一个字符串。 split将创建一个新数组并对其进行迭代，并检查字符串的其余部分是否存在此字符。

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

我使用对象来执行此操作，并且我对是否存在另一种方法感到好奇，因为我也想采用算法方法，但是任何可行的方法都可以。

无论如何，这是代码：

Item

逻辑基本上是只保存每个字符串的所有字符及其计数，检查相似性并比较常见字符的计数。共有较少数量的公共字符将是双方共享的数量。

O（3N）时间复杂度，O（2N）空间复杂度（由于存储的对象）。我想我也可以“删除对象”，但是在算法IDE上似乎是多余的，因为它不像它在服务器上运行了任何长时间。

Answer 6

function commonSameCount(s1, s2) {
    var s1Array = s1.split("");
    var s2Array = s2.split("");
    var count = 0;
    let index = 0;
    
    s1Array.filter(s1 => {
        index = s2Array.findIndex(s2 => s2 == s1);
        if(index >= 0){
            count++;
            s2Array.splice(index, 1);
        }
    });
    return count;
}

如何计算javascript中两个字符串中的公共字符？

6 个答案: