arrays - 如何按顺序在 int 数组中找到相同的值(重复)？

Question

这是一个基本的老虎机游戏我正在快速编码，我有一个由 7 个数字组成的 int 数组。

int数组可以有1到7个值，它们是随机放置的。

   1> [1, 2, 4, 7, 7, 7, 7]
   2> [3, 3, 5, 7, 5, 3, 3]
   3> [5, 5, 5, 2, 5, 1, 5]
   4> [2, 2, 2, 2, 2, 2, 2]

这些是数组可以具有的示例。

In the 1st array you can see that there are 4 pairs of 7s.

In the 3rd array the first 3 are another 3 pair 5s

我该怎么做，这就是我所拥有的。

func processWin(val : Array<Int>){

        var counter = 0;
        var oldValue = 0;

        for num in val {
            if num == oldValue {
                counter++;
            }

            oldValue = num;        
        }

        if counter == 3 {
            print("Three in a row!!!")
        }

        if counter == 4 {
            print("Four in a row!!!")
        }

        if counter == 5 {
            print("Five in a row!!!")
        }
        if counter == 6 {
            print("Six in a row!!!")
        }
        if counter == 7 {
            print("BOOM!")
        }
        print(counter)
    }

更新

如果数组是[2, 2, 2, 2, 2, 2, 2] 打印 BOOM

如果数组是[1, 2, 4, 7, 7, 7, 7] 打印 一行四个

如果数组是[5, 5, 5, 2, 5, 1, 5] 打印 连续三个

如果数组是[3, 3, 3, 2, 5, 5, 5] 打印 一行三 & 一行三

如果数组是 [7, 7, 7, 7, 5, 5, 5] 打印 一行四行 & 一行三行

Answer 1

稍微拆分代码中的逻辑可能是个好主意。例如，将数字转换为其等效的英语单词非常适合扩展:

extension Int {
  var english: String {
    switch self {
    case 0: return "Zero"
    case 1: return "One"
    case 2: return "Two"
    case 3: return "Three"
    case 4: return "Four"
    case 5: return "Five"
    case 6: return "Six"
    case 7: return "Seven"
    case 8: return "Eight"
    case 9: return "Nine"
    default: return description
    }
  }
}

在序列中对相似元素进行分组也可以单独定义:

extension SequenceType where Generator.Element: Equatable {
  func group() -> [(Generator.Element, Int)] {
    var res: [(Generator.Element, Int)] = []
    for el in self {
      if res.last?.0 == el {
        res[res.endIndex-1].1 += 1
      } else {
        res.append((el,1))
      }
    }
    return res
  }
}

然后你的函数会更短一些并且更具可读性:

extension SequenceType where Generator.Element: Equatable {
  func processWin() -> String {
    return self
      .group()
      .lazy
      .filter { (_,c) in c > 1 }
      .map { (e,c) in c >= 7 ? "Boom!" : c.english + " \(e)s" }
      .joinWithSeparator(", and ")
  }
}

它可以这样使用:

[1, 2, 4, 7, 7, 7, 7].processWin() // "Four 7s"
[3, 3, 5, 7, 5, 3, 3].processWin() // "Two 3s, and Two 3s"
[5, 5, 5, 2, 5, 1, 5].processWin() // "Three 5s" 
[2, 2, 2, 2, 2, 2, 2].processWin() // "Boom!"