Swift 比较数组中的索引

我有一个数字数组，我想检查

索引1

中的数字是否等于

索引2

中的数字，如果是，我想将计数器增加1。我已经尽了我所能，但没有想出正确的逻辑

这就是我迄今为止所尝试的

let c: [Int] = [0, 0, 0, 0, 1, 0]

for (index, val) in c.enumerated() {
        print(val)
        var counts = 0
        if c.firstIndex(of: index) == c.index(after: index) {
            print("yes")
            counts += 1
            print(counts)
        }
    }

因此，将0

索引0

与0

索引1

进行比较，计数器增加1，
然后0

index 1

到0

index 2

计数器增加1，
然后0

索引2

到0

索引3

计数器增加1
然后从0

index 3

跳到1

index 4

skip，
然后0

索引3

到0

索引5

计数器增加1

尝试

let c: [Int] = [0, 0, 0, 0, 1, 0]

var counter  = 0

var lastIndexOfZero = 0

for index in 1..<c.count {

    if c[lastIndexOfZero] == c[index] {
        counter += 1
    }

    if c[index] == 0 {
        lastIndexOfZero = index
    }
}

print(counter)

试试这个：）

让数字=[0,0,0,0,1,0]
让count=numbers.enumerated（）.reduce（0）{result，tuple in
设nextofset=tuple.offset+1
警卫
nextofset

这将为您的阵列返回

3

。

尝试以下操作：

let c: [Int] = [0, 0, 0, 0, 1, 0]

let numberOfCycles = c.count-2

var count = 0
for i in 0...numberOfCycles {
    if c[i] == c[i+1] {
        count += 1
    }
}

print(count)

眼前的问题 在您的案例中，特别的问题是

c.firstIndex（of:index）

在

c

中查找

index

的第一个索引。我想你是想写c.firstIndex（of:val），但即使这样也不行。例如，如果您询问

c.firstIndex（of 0）

，它将始终为您提供

0

，即使您在数组的中间，因为在您的测试用例中，第一个

0

元素始终位于索引

0

另一个问题是您的

count

在循环范围内，这意味着每次迭代都会得到自己独立的

count

变量，初始化为

0

，在重新初始化之前，该变量最多会增加到

1

清洁剂 这是一个更实用的风格的理想案例。它简单得多，但也非常简单

解决方案由4个步骤组成：

使用

zip（a，a.dropFirst（））

模式，对于由

[1,2,3,4,5]

组成的数组

a

将生成一个相邻元素对的数组，如

[（1,2）、（2,3）、（3,4）、（4,5）]

从这里开始，就需要检查每一对，看看它们的两个元素是否相同。如果是这样，我们将它们更改为

0

，否则更改为

1

然后我们将这些数字相加，得到最终结果

理想情况下，我们将此代码打包成一个函数，并使其具有通用性，以便易于重用

因此，我们得到：

extension Sequence where Element: Equatable {
    func countOfAjacentDifferingElements() -> Int {
        return zip(self, self.dropFirst())
            .lazy
            .map { $0 == $1 ? 1 : 0 }
            .reduce(0, +)
    }
}

let numbers = [0, 0, 0, 0, 1, 0]
print(numbers.countOfAjacentDifferingElements()) // => 2

---

---

对如果不是，则跳转该值并与前一个值相等的下一个值进行比较我已更新了问题值只能是0和1，但最后的0和最后的1后面跟一个相同的数字，因此您只需返回

c.count-2

（假设数组中既有0也有1，否则它是

c.count-1

）我不明白，我更新了这个问题，它没有返回正确的答案output@King是的，我刚把你的数组形式[0,0,0,0,1,0]改成[0,0,1,1,0]@King把它改成你想要的[0,0,1,0,0,1,0]@如果数组是[0,0,1,0,0,0,1,0]，它将重新运行2，这是错误的。如果数组是[0,0,1,0,0,1,0]，则是同一问题，它重新计算了2，这是错误的，它应该是4，为什么它应该是4？找到的索引是0和3，还有什么其他索引应该增加计数器？既然索引2是3，你比较索引1和索引4，我不明白你问什么对不起，索引2=1，我没有比较索引1和索引4。我认为你应该重新制定你试图实现的目标Ve但是[0 0 1 0 0 1 0]给出的是2而不是4hmm，我不明白为什么它应该给出4。只有两对相邻的相等元素，用括号显示：

[（0）1（0）1 0]

[a，b，c，d，e，f，g]，a到b，b到d，d到e，e到g]哦，那么你是在计算不同元素的对吗？在这种情况下，你只需切换

0

和

1

，这样当

=

返回false时，计数就会增加：

$0==1？0:1

let c: [Int] = [0, 0, 0, 0, 1, 0]

let numberOfCycles = c.count-2

var count = 0
for i in 0...numberOfCycles {
    if c[i] == c[i+1] {
        count += 1
    }
}

print(count)

extension Sequence where Element: Equatable {
    func countOfAjacentDifferingElements() -> Int {
        return zip(self, self.dropFirst())
            .lazy
            .map { $0 == $1 ? 1 : 0 }
            .reduce(0, +)
    }
}

let numbers = [0, 0, 0, 0, 1, 0]
print(numbers.countOfAjacentDifferingElements()) // => 2