关于ios：Int数组的数组。 仅按顺序存储重复项


Arrays of Int arrays. Storing duplicates in order only

我需要为有序重复项(位于数组中)存储一个Int数组的数组。

例：

  • 给定数组：
    mainArray = [7, 7, 3, 2, 2, 2, 1, 7, 5, 5]

现在，我需要创建一个int Array的2D数组。
例：

1
2
3
4
5
6
7
8
Array [][] = [
               [7, 7],
               [3],
               [2, 2, 2],
               [1],
               [7],
               [5, 5]
             ]

这是我所拥有的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
for var i = 0; i < val.count; i++ {
    var columnArray = Array<Int>()
    for var j in 0...9 {
        if oldNum == val[j]{
            columnArray.append(val[j])
        }
        else {
            array.append(columnArray);
            //j += 1
            break;
        }
        oldNum = val[j];
        j += 1
    }
}
相关讨论

您可以使用reduce方法。

1
2
3
4
5
6
7
8
let result = numbers.reduce([[Int]]()) { (var result, num) -> [[Int]] in
    if var lastSequence = result.last where lastSequence.first == num {
        result[result.count-1].append(num)
    } else {
        result.append([num])
    }
    return result
}

还原如何工作？

reduce确实将闭包中的逻辑应用于空的2D整数数组([[Int]])和numbers的第一张Elm。

然后将其再次应用于上一次迭代的结果和第二个整数数组...等等。

关闭会发生什么？

if确实检查添加到结果中的最后一个数组中的数字是否等于当前检查的整数。如果是这样，则将该整数添加到该数组。

否则，将仅包含新整数的新数组添加到结果中。

测试

1
[[7, 7], [3], [2, 2, 2], [1], [7], [5, 5]]
相关讨论

在元素相等的情况下扩展集合的另一种方法

1
2
3
4
5
6
7
8
9
10
11
12
13
extension Collection where Element: Equatable {
    var grouped: [[Element]] {
        var result: [[Element]] = []
        for element in self {
            if element == result.last?.last {
                result[result.index(before: result.endIndex)].append(element)
            } else {
                result.append([element])
            }
        }
        return result
    }
}
1
2
3
let array = [7, 7, 3, 2, 2, 2, 1, 7, 5, 5]

array.grouped  // [[7, 7], [3], [2, 2, 2], [1], [7], [5, 5]]

这是我能想到的最无聊的迭代答案。另一方面，它很容易理解，并且不会像基于reduce的解决方案那样潜在地出现复杂性问题：

1
2
3
4
5
6
7
8
9
10
11
12
13
var result: [[Int]] = []
var inner: [Int] = []

for i in mainArray {
  if i == inner.last {
    inner.append(i)
  } else {
    result.append(inner)
    inner = [i]
  }
}
result.append(inner)
// result == [[7, 7], [3], [2, 2, 2], [1], [7], [5, 5]]

您可以使用forEach并保留最后一个元素的值以继续添加到数组中，而这不会像下面这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
let mainArray = [7, 7, 3, 2, 2, 2, 1, 7, 5, 5]

func filterTo2DArray(list: [Int] ) -> [[Int]] {

   var resultList = [[Int]]()

   list.forEach { x -> () in
      if let lastValue = resultList.last?.last where lastValue == x {
          resultList[resultList.count - 1].append(x)
      }
      else{
         resultList.append([x])
      }
   }
   return resultList
}


let t = filterTo2DArray(mainArray) //[[7, 7], [3], [2, 2, 2], [1], [7], [5, 5]]

希望对您有所帮助。

相关讨论

以下代码将为您提供所需的信息...

1
2
3
4
5
6
7
8
9
10
11
12
let mainArray = [7, 7, 3, 2, 2, 2, 1, 7, 5, 5]
var newArray: [[Int]] = []

for var i=0; i < mainArray.count; i++ {
    let element = mainArray[i]
    if mainArray.indexOf(element) == i {
      var subArray = mainArray.filter({ $0 == element })
      newArray.append(subArray)
    }
}

print(newArray) // -> [[7, 7, 7], [3], [2, 2, 2], [1], [5, 5]]

这是一个编程逻辑问题。您当前的代码是完全错误的。

这是解决问题的一种方法：

通过对起始数组进行排序来开始。调用该inputArray。

创建新的空输出" outerArray"和" innerArray"变量。然后循环遍历inputArray中的条目，测试值的变化。如果该值与最后一个值相同，则将该值添加到" innerArray"。如果值已更改，则将以前的innerArray保存到externalArray并创建一个新的空数组，然后将其保存到innerArray。