Swift:将值集 A 映射到 B 和 B 映射到 A

Question

任务：

考虑一组值，例如0, 1, 2， 现在想象其中两个集合以及它们之间的双射关系。

如何在封装在数据结构中的 Swift 中实现这一点？

澄清和示例：

示例映射可能如下所示：

0 <-> 1
1 <-> 2
2 <-> 0

经典的双向哈希图不太适合这个用例，因为两侧的值都是非唯一的。

数据结构应允许从两端进行查询：

let ds = DS(...)
let ds.right(from: 1) // 2
let ds.left(from: 0) // 2

实现这种数据结构的最简单方法是什么？我的实现可以基于哪些现有数据类型？

更新：

什么是"两侧的值都是非唯一的"左"侧的值在该侧是唯一的，"右"侧的值也是如此。但是，如果值存在于一侧，则它将始终存在于另一侧。因此，这些值不是唯一的。

您能否举一个非唯一值的示例，以及在非唯一性的情况下右(从：)和左(从：)的预期结果？

澄清一下，左侧的所有值都是0,1,2.右侧也有0,1,2.

查询示例：

ds.rightFrom(left: 2) -> 0
ds.rightFrom(left: 0) -> 1

ds.leftFrom(right: 0) -> 2
ds.leftFrom(right: 1) -> 0

Answer 1

从集合到自身的双射函数是一种排列。如果集合由从零开始的连续整数组成，则排列可以表示为数组。

在您的情况下，从 [0， 1， 2] 到自身的映射由

0 -> 1, 1 -> 2, 2 -> 0

将表示为数组[1, 2, 0]。然后，"从左到右"映射成为下标操作：

let perm = [1, 2, 0]
print(perm[1]) // 2

"从右到左"映射是反向排列，也可以表示为数组：

func inversePermution(of perm: [Int]) -> [Int]? {
var inverse: [Int] = Array(repeating: -1, count: perm.count)
for (idx, elem) in perm.enumerated() {
// Check for valid entries:
guard elem >= 0 && elem < perm.count else { return nil }
// Check for duplicate entries:
guard inverse[elem] == -1 else { return nil }
// Set inverse mapping:
inverse[elem] = idx
}
return inverse
}

(这只是为了演示一般想法。当然，您可以将其设置为Array扩展方法，或者使用此方法和更多方法定义Permutation类型。

在您的示例中：

if let invPerm = inversePermution(of: perm) {
print(invPerm) // [2, 0, 1]
print(invPerm[2]) // 1
}

Answer 2

您可以在array上使用zip(_:_:)，即

let arr1 = [0,1,2]
let arr2 = [01,2,0]
let result = Array(zip(arr1,arr2))
print(result) //Output: [(0, 1), (1, 2), (2, 0)]

Answer 3

我已经完成的代码：

import Foundation
public struct BidirectionalMapNonUnique<Left, Right> where Left: Hashable, Right: Hashable {
private let ltr: [Left: Right]
public let rtl: [Right: Left]
public init(_ ltrMapping: [Left: Right]) {
var rtlPending = [Right: Left]()
for (key, value) in ltrMapping {
rtlPending[value] = key
}
self.ltr = ltrMapping
self.rtl = rtlPending
}
public func leftFrom(right: Right) -> Left {
return rtl[right]!
}
public func rightFrom(left: Left) -> Right {
return ltr[left]!
}
}

let example = BidirectionalMapNonUnique<Int, Int>([0:10, 1:11, 2:12])
print(example.leftFrom(right: 11)) // Prints 1
print(example.rightFrom(left: 0)) // Prints 10