我有一個包含不同元素的陣列，它看起來像這樣：
Vehicles = [ Auto(brand: "bmw", color: "red"),
Auto(brand: "mazda", color: "red"),
Auto(brand: "alfa romeo", color: "red"),
Bike(brand: "suzuki", color: "blue"),
Bike(brand: "yamaha", color: "black") ]
在這種情況下，我需要根據“顏色”反轉它，因此陣列將如下所示：
Vehicles = [ Auto(brand: "alfa romeo", color: "red"),
Auto(brand: "mazda", color: "red"),
Auto(brand: "bmw", color: "red"),
Bike(brand: "suzuki", color: "blue"),
Bike(brand: "yamaha", color: "black") ]
具有相同顏色的元素相互跟隨，例如“子組”，我需要反轉這些子組中的每一個。即： [a,b,c,d,e,f,g,h,i], 如果 a,b,c 是顏色 1, d,e,f 顏色 2, g,h,i 是顏色 3,就像 [(a,b,c), (d,e,f), (g,h,i)]，順序應該是 [(c,b,a), (f, e, d), ( i,h,g)]，所以 [c,b,a,f,e,d,i,h,g]
uj5u.com熱心網友回復：
您可以分三步執行此操作：
根據顏色變化將您的收藏分解為子收藏。Apple 的swift-algorithms包有一個名為的運算子
chunked(by:)，非常適合此操作。在此處閱讀有關向您的應用程式添加包依賴項的資訊。反轉每個子集合。您可以
reversed()為此使用標準庫方法。連接子集合。您可以
joined()為此使用標準庫方法。
vehicles = vehicles
.chunked { $0.color == $1.color }
.map { $0.reversed() }
.joined()
如果您想在chunked謂詞中使用更復雜的邏輯，則需要使用命名引數，以便宣告其回傳型別：
vehicles = vehicles
.chunked { a, b -> Bool in
switch (a.type, b.type) {
case (.car, .car): return a.color == b.color
case (.bike, .bike): return a.color == b.color
default: return false
}
}
.map { $0.reversed() }
.joined()
uj5u.com熱心網友回復：
使用模型和輸入：
protocol Vehicle: CustomStringConvertible {
var brand: String { get set }
var color: String { get set }
}
extension Vehicle {
var description: String {
"Brand: \(brand) - color: \(color)"
}
}
struct Bike: Vehicle {
var brand: String
var color: String
}
struct Auto: Vehicle {
var brand: String
var color: String
}
let vehicles: [Vehicle] = [ Auto(brand: "bmw", color: "red"),
Auto(brand: "mazda", color: "red"),
Auto(brand: "alfa romeo", color: "red"),
Bike(brand: "suzuki", color: "blue"),
Bike(brand: "suzuki2", color: "blue"),
Bike(brand: "suzuki3", color: "blue"),
Bike(brand: "yamaha", color: "black"),
Bike(brand: "yamaha2", color: "black")]
一個可能的解決方案，不需要rob mayoff 提到的Apple 額外的收藏包
// Here we create batches, ie subgroups of Vehicle with the same color using `reduce(into:_)`
let batched = vehicles.reduce(into: [[Vehicle]]()) { partialResult, aVehicle in
//If there is already a batch, we check the last one, and inside that batch, we check the last Vehicle color
// If it's the same color of the one currently checked (aVehicle), then we append it
if var lastBatch = partialResult.last, let lastVehicle = lastBatch.last, lastVehicle.color == aVehicle.color {
lastBatch.append(aVehicle)
partialResult[partialResult.count - 1] = lastBatch
} else {
partialResult.append([aVehicle]) //We create a new batch
}
}
print("batched: \(batched)")
// Here we reverse each batch
let reversedBatch = batched.map { aBatch -> [Vehicle] in
return aBatch.reversed() //return can be omitted here
}
print("reversedBatch: \(reversedBatch)")
//We remove the subgroup, flattening the array
let reversed = reversedBatch.flatMap { $0 }
print("reversed: \(reversed)")
現在，我們有了主要的想法，我們可以一次性完成第一個操作和第二個操作。我們沒有追加，而是將其作為批次的開始
let batchedAndReversed = vehicles.reduce(into: [[Vehicle]]()) { partialResult, aVehicle in
if var lastBatch = partialResult.last, let lastVehicle = lastBatch.last, lastVehicle.color == aVehicle.color {
lastBatch.insert(aVehicle, at: 0)
partialResult[partialResult.count - 1] = lastBatch
} else {
partialResult.append([aVehicle]) //We create a new batch
}
}
let reversed2 = batchedAndReversed.flatMap { $0 }
print("reversed2: \(reversed2)")
uj5u.com熱心網友回復：
您可以按顏色對陣列進行排序，然后使用該.sorted(by:)函式將其反轉。然后您可以使用該.reversed()功能反轉它。
let sortedVehicles = vehicles.sorted(by: { car1, car2 -> Bool in
car1.color < car2.color
}).reversed()
提供的閉包確定 是否car1應該在car2排序陣列之前。
如果你想就地作業，你可以使用sort(by:)andreverse()函式（或者反轉排序謂詞）：
vehicles.sort(by: ...)
vehicles.reverse()
轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/354982.html