快速：比较2个字符数组，从每个字符数组中删除一个值

Question

Here's what I'm trying to do. I'm making a game where opponents guess each other's word, and each guess has direct and indirect hits. See asterisks for where I'm having an issue.

var directSum = 0
var indirectSum = 0
var words = ["canon", "cnams"]
var secretWord = Array(words[0].characters)
var guessWord = Array(words[1].characters)
var secretWordInd = [Character]()
var guessWordInd = [Character]()

let dir1 = secretWord[0] == guessWord[0]
let dir2 = secretWord[1] == guessWord[1]
let dir3 = secretWord[2] == guessWord[2]
let dir4 = secretWord[3] == guessWord[3]
let dir5 = secretWord[4] == guessWord[4]


if dir1 && dir2 && dir3 && dir4 && dir5 {
    print ("you won!")
}
    if dir1 {
        directSum += 1
    } else {
        secretWordInd.append(secretWord[0])
        guessWordInd.append(guessWord[0])
}
    if dir2 {
        directSum += 1
    } else {
        secretWordInd.append(secretWord[1])
        guessWordInd.append(guessWord[1])
}
    if dir3 {
        directSum += 1
    } else {
        secretWordInd.append(secretWord[2])
        guessWordInd.append(guessWord[2])
}
    if dir4 {
        directSum += 1
    } else {
        secretWordInd.append(secretWord[3])
        guessWordInd.append(guessWord[3])
}
    if dir5 {
        directSum += 1
    } else {
        secretWordInd.append(secretWord[4])
        guessWordInd.append(guessWord[4])
**}

for var secretLetter in secretWordInd {
    for var guessLetter in guessWordInd{
        if secretLetter == guessLetter {
            secretWordInd.remove(at:secretWordInd.indexOf(secretLetter))
            guessWordInd.remove(at:guessWordInd.indexOf(guessLetter))
            indirectSum += 1
            }
        }
    }**
var score = [directSum, indirectSum]

what I need to do is count every time there's a character in Array:SecretWordInd that matches a character in Array:guessWordInd, remove only those two characters(one from each string), and indirectSum += 1 for every time this occurs. If there are 2 "a"s in one and 1 in the other, for instance, the function needs to remove 1 a from each. That means the output of the function for directSum, indirectSum in this case should be [1,2] since there is only one indirect hit from one "n" from the guess word. This is what is making the function complicated for me. The number of values in both arrays will not be constant. I can't figure out how to use a method to do this(.contains is for only strings I think). Your help is greatly appreciated! Thanks!

Answer 1

As others have said this isn't the place for homework ;)

But here are some pointers as to what might be useful:

indexOf : returns index of element you are looking for, nil if not in set

remove : remove from an array

Answer 2

You should look into Array, Set and String data types in the documentation, they provide lots of functions to perform that kind of calculations and transformations.

For example:

var secretWord = "canon"
var guessWord  = "cnams"

// identify shared letters using sets
let sharedLetters  = Set(secretWord.characters).intersection(Set(guessWord.characters))

// count number of shared letters present in both words
let sharedCounts   = sharedLetters.map{  c      in (c, secretWord.characters, guessWord.characters) }
                                  .map{ (c,s,g) in (c, s.filter{$0==c}, g.filter{$0==c}) } 
                                  .map{ (c,s,g) in (c, min(s.count,g.count)) }

// count same letters at same position and shared
// (if you're making a mastermind game, you should subtract directCount from indirectCount)                                 
let directCount   = zip(secretWord.characters,guessWord.characters).filter{$0==$1}.count
let indirectCount = sharedCounts.map{$0.1}.reduce(0,+)                                 


// remove shared letters (for count) from both strings
sharedCounts.flatMap{ Array(repeating:$0, count:$1) }
            .forEach{ secretWord.remove(at:secretWord.characters.index(of:$0)!) }
sharedCounts.flatMap{ Array(repeating:$0, count:$1) }
            .forEach{ guessWord.remove(at:guessWord.characters.index(of:$0)!) }


sharedLetters  // {"n", "a", "c"}
sharedCounts   // ("n", 1), ("a",1), ("c", 1)]
directCount    // 1
indirectCount  // 3    
secretWord     // "on"
guessWord      // "ms"