Question

这是一款基本的老虎机游戏我在swift中编码，我有一个包含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]

这些是数组可以拥有的例子。

在第一个数组中，您可以看到有4对7。

在第3阵列中，前3位是另外3对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] 打印 BOOM

如果数组为[1,2,4,7,7,7,7] 打印 Four in a Row

如果数组是[5,5,5,2,5,1,5] 打印 Three in a Row

如果阵列是[3,3,3,2,5,5,5] 打印 Three in a Row＆amp; Three in a Row

如果阵列为[7,7,7,5,5,5,5] 打印 Four in a Row＆amp; Three in a Row

Answer 1

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

<% var foo = new RouteValueDictionary(ViewContext.RouteData.Values);
   foo["id"] = 2;
   var newUrl = Url.Action(foo["action"].ToString(), foo); %>

对序列中的类似元素进行分组也可以单独定义：

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 ")
  }
}

Answer 2

我会使用字典来计算输入数组中出现的次数，然后我会打开计数。

let a = [1, 2, 4, 7, 7, 7, 7]
let b = [3, 3, 5, 7, 5, 3, 3]
let c = [5, 5, 5, 2, 5, 1, 5]
let d = [2, 2, 2, 2, 2, 2, 2]

func processWin(val: [Int]) {
    var counts: [Int : Int] = [1:0, 2:0, 3:0, 4:0, 5:0, 6:0, 7:0]

    for item in val {
        counts[item] = counts[item]! + 1
    }

    for (key, value) in counts where value > 1{
        switch value {
            case 2:
                print("A pair of \(key)s")
            case 3:
                print("Three \(key)s")
            case 4:
                print("Four \(key)s")
            case 5:
                print("Five \(key)s")
            case 6:
                print("Six \(key)s")
            case 7:
                print("Seven \(key)s")
            default:
                print("No duplicates")
        }
    }
}

print("A")
processWin(a)
print("B")
processWin(b)
print("C")
processWin(c)
print("D")
processWin(d)

这会产生以下输出：

A
Four 7s
B
A pair of 5s
Four 3s
C
Five 5s
D
Seven 2s

Answer 3

我注意到有关您当前代码的一些事情：

您将永远只是一个实际数字中的一个，因为您在counter开始0时根据定义，每个数字至少是“连续一行”
如果是[1,1,1,2,3,3,3]这样的数组，当一行中的最大数字为4时，您会得到3的错误值。

要解决第一个问题，请在counter处开始1，然后修复第二个问题，跟踪maxInARow变量，并在counter时重置num != oldValue {1}}。

func processWin(val: Array<Int>) { 
    var counter = 1 
    var oldValue = 0
    var maxInARow = 0 

    for num in val { 
        if num == oldValue { 
            counter++
            if counter > maxInARow {
                maxInARow = counter 
            } 
        } else {
            counter = 1 
        } 
        oldValue = num 
    } 

    print(maxInARow)
}

Answer 4

我跑了7次尝试了不同的阵列。我稍微编辑了你的代码，这运行得很好。我每次都得到同样的答案。试试这个，看看你是否遇到同样的问题。我建议使用switch语句而不是所有这些if语句。

var val:[Int] = [2,2,2,2,2,2,2]

func processWin(val : Array<Int>){
var counter = 1
var oldValue = 0
for num in val {

    if num == oldValue {
        counter += 1
        print(counter)
    }

    oldValue = num
}

switch counter {
case 3:
    print("Three in a row!!!")
case 4:
     print("Four in a row!!!")
case 5:
    print("Five in a row!!!")
case 6:
    print("Six in a row!!!")
case 7:
    print("BOOM!")
default:
    print("Sorry")
}

print(counter)
}

processWin(val)
//prints BOOM!

此外，您的计数器需要从1开始。我不完全确定您的代码发生了什么，但我的工作似乎正常。

如何按顺序在int数组中找到相同的值（重复）？

4 个答案: