【问题标题】：Compare two strings for duplicates and string position比较两个字符串的重复项和字符串位置
【发布时间】：2018-10-08 03:21:28
【问题描述】：

我正在编写一个函数来比较两个长度相同的字母数组，以检查两个条件。

array1 是否包含与array2 相同的值（逐个键）
同一索引位置的值是否相同？

我的函数实现这一点有一个副作用，如果array1 多次包含同一个字母，但array2 没有，它会将其标记为包含该字母。

这是我目前所拥有的：

const compareWords = (array1, array2) => {
    let guess = []

    array1.forEach((letter, i) => {
        let guessMap = { letter }

        // Does the word contain the correct letter
        if (array2.includes(letter)) {
            guessMap.includes = true

            // Is the correct letter in the same position?
            if (array1[i] === array2[i]) {
                guessMap.samePos = true
            } else {
                guessMap.samePos = false
            }
        } else {
            guessMap.includes = false
            guessMap.samePos = false
        }
        guess.push(guessMap)
    })
    console.log(guess)
}
compareWords( ['M', 'O', 'M'], ['M', 'A', 'P'] )

带电流功能的输入/输出：

compareWords( ['M', 'O', 'M'], ['M', 'A', 'P'] )

[ { letter: 'M', includes: true, samePos: true },
  { letter: 'O', includes: false, samePos: false },
  { letter: 'M', includes: true, samePos: false } ]

所需的示例输入/输出

compareWords( ['M', 'O', 'M'], ['M', 'A', 'P'] )

[ { letter: 'M', includes: true, samePos: true },
  { letter: 'O', includes: false, samePos: false },
  { letter: 'M', includes: false, samePos: false } ]

compareWords( ['M', 'O', 'M'], ['M', 'A', 'M'] )

[ { letter: 'M', includes: true, samePos: true },
  { letter: 'O', includes: false, samePos: false },
  { letter: 'M', includes: true, samePos: true } ]

compareWords( ['M', 'O', 'M'], ['H', 'M', 'M'] )

[ { letter: 'M', includes: true, samePos: false },
  { letter: 'O', includes: false, samePos: false },
  { letter: 'M', includes: true, samePos: true } ]

【问题讨论】：

你的预期输出是什么？

标签： javascript string-comparison

【解决方案1】：

试试这个，这不是一种优雅的方法，但它可能适用于您的预期目的：

const compareWords = () => {
    const currentGuess = ['M', 'O', 'M', 'E', 'P']
    const currentWord = ['M', 'A', 'P', 'E', 'R']
    let guess = [];

    for (let i in currentGuess) {
        const letter = currentGuess[i];
        // Check if this letter was previously stated 
        const previousGuess = guess.find(g => g.letter === letter);
        const guessMap = { letter };
        const currentWordSubset = !!previousGuess ? currentWord.filter((v, i) => i > previousGuess.foundAt) : currentWord;
        if (currentWordSubset.includes(letter)) {
            guessMap.includes = true;
            guessMap.foundAt = currentWord.indexOf(letter);
            if (currentWord[i] === currentGuess[i]) {
                guessMap.samePos = true
            } else {
                guessMap.samePos = false
            }
        } else {
            guessMap.includes = false;
            guessMap.samePos = false;
        }
        guess.push(guessMap);
    }
    console.log(`Comparing: ${currentGuess.join('')} vs ${currentWord.join('')}`);
    guess.forEach(g => { 
        if (!!g.foundAt || g.foundAt === 0) { delete g.foundAt}
        return g; 
    })
    console.log(guess);
}

compareWords();

输出

Comparing: MOMEP vs MAPER
[ { letter: 'M', includes: true, samePos: true },
  { letter: 'O', includes: false, samePos: false },
  { letter: 'M', includes: false, samePos: false },
  { letter: 'E', includes: true, samePos: true },
  { letter: 'P', includes: true, samePos: false } ]

【讨论】：

【解决方案2】：

您可以做的是从数组2 创建一个对象。它将属性作为数组 2 中的元素，值作为它们在数组 2 中的次数。之后，您应该遍历array1并查看元素当前元素是否在array2中以及计数是否> 0。如果它是真的，那么您将不得不减少该元素的计数，您将知道该元素在 array2 中。为了在遍历 array1 时的位置，您还必须像在代码中所做的那样遍历 array2。

const currentGuess = ['M', 'O', 'M']
const currentWord = ['M', 'A', 'P']
let guess = new Object()
let ans = []

currentWord.forEach((item, index) => {
    if( quess.hasOwnProperty(item) {
        guess[item]++
    }
    else{
        guess[item] = 1
    }
})

for(let index = 0; index < currentGuess.length; index++){
    if(guess.hasOwnProperty(currentGuess[index]) and 
    guess[currentGuess[index]]>0 and 
    currentGuess[index]===currentWord[index]){
        guess[currentGuess[index]]--
        console.log("{ letter: '"+currentGuess[index]+"', includes: true, 
        samePos: true },")        
    }
    else if(currentGuess[index]]>0 and 
    currentGuess[index]!=currentWord[index] ){
        console.log("{ letter: '"+currentGuess[index]+"', includes: true, 
        samePos: false},")
    }
    else{
       console.log("{ letter: '"+currentGuess[index]+"', includes: false, 
        samePos: false},")
    }


}

【讨论】：

检查我在答案中的编辑，我已包含代码。
这是迄今为止最接近的解决方案，我做了一些修改以使代码更简洁，我将在我原来的问题中更新

【解决方案3】：

你可以用数组映射把它写得更短：

const compareWords = () => {
    const currentGuess = ['M', 'O', 'M'];
    const currentWord = ['M', 'A', 'P'];
    let guess = currentGuess.map((current,index)=>{
      let obj = {};
      obj["letter"] = current;
      obj["includes"] = currentWord.includes(current);
      obj["samePos"] = current === currentWord[index];
      return obj;
    });
    console.log(guess);
}
compareWords();

【讨论】：

这段代码很干净，我已经在我的最终解决方案中使用过；但是，它完全符合我的原始代码的功能。

【解决方案4】：

您还需要检查一件事。如果array1多次包含相同的字母，那么您可以在第一次检查时将其推送到数组中，然后将在条件中检查它是否存在于数组中。

const compareWords = () => {
const currentGuess = ['M', 'O', 'M'];
const currentWord = ['M', 'A', 'P'];
let guess = [];
const exist = [];

currentGuess.forEach((letter, i) => {
    let guessMap = { letter };

    // Does the word contain the correct letter and if it is not compared previously
    if (currentWord.includes(letter) && !exist.includes(letter)) {
        guessMap.includes = true;
        exist.push(letter);

        // Is the correct letter in the same position?
        if (currentWord[i] === currentGuess[i]) {
            guessMap.samePos = true;
        } else {
            guessMap.samePos = false;
        }
    } else {
        guessMap.includes = false;
        guessMap.samePos = false;
    }
    guess.push(guessMap);
})
console.log(guess);

}

【讨论】：

如果第二个单词从不包含重复字母，则此解决方案有效，但如果包含重复字母则失败。不过谢谢，它让我走上了正确的道路

【解决方案5】：

我的解决方案是使用reduce，例如：

const compareWords = () => {
  const currentGuess = ['M', 'O', 'M']
  const currentWord = ['M', 'A', 'P']
  
  const result = currentGuess.reduce((result, currentGuessCharacter, currentGuessIndex) => {
    const currentWordIndexFound = currentWord.findIndex(currentWordCharacter => currentWordCharacter === currentGuessCharacter);    

    return [
      ...result,
      { 
        letter: currentGuessCharacter, 
        includes: currentWordIndexFound > -1, 
        samePos: currentGuessIndex === currentWordIndexFound 
      }
    ]
  }, []);

  console.log(result);
}

compareWords();

【讨论】：

【解决方案6】：

我使用了来自 @protoproto 和 @monil-bansal 的示例来提出以下解决方案。

const compareWords = (word1, word2) => {
    let wordLetterCount = word2.reduce((result, letter) => {
        result[letter] = (result[letter] || 0) + 1
        return result
    }, {})

    const checkIncludes = (letter) => {
        if (word2.includes(letter) && wordLetterCount[letter] > 0) {
            wordLetterCount[letter]--
            return true
        } else {
            return false
        }
    }

    const guess = word1.map((letter, i) => {
        return {
            letter,
            includes: checkIncludes(letter),
            samePos: letter === word2[i]
        }
    });

    console.log(guess)
}
compareWords( ['M', 'O', 'M'], ['M', 'A', 'P'] )
compareWords( ['M', 'O', 'M'], ['M', 'A', 'M'] )
compareWords( ['M', 'O', 'M'], ['H', 'M', 'M'] )

【讨论】：