比较两个字符串的重复项和字符串位置

Question

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

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'] )

Input/Output w/Current 函数：

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 } ]

想要的例子Input/Output

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 } ]

Answer 1

您可以做的是从 array2 创建一个对象。它会将属性作为 array2 中的元素，并将值作为它们在 array2 中的次数。之后你应该遍历 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},")
    }


}

Answer 2

试试这个，这不是一个优雅的方法，但它可能会达到您的预期目的：

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 } ]

Answer 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();

Answer 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);

}

Answer 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();

Answer 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'] )

比较两个字符串的重复项和字符串位置

Compare two strings for duplicates and string position

javascript

string-comparison

Input/Output w/Current 函数：

想要的例子Input/Output