在 Python 中反转排列

Question

我是编程新手，我正在尝试编写一个 Python 函数来使用以下代码查找 {1,2,3,...,n} 上的逆排列：

def inv(str):
    result = []
    i = list(str).index(min(list(str)))
    while min(list(str)) < len(list(str)) + 1:
        list(str)[i : i + 1] = [len(list(str)) + 1]
        result.append(i + 1)
    return result

但是，当我尝试使用该函数时，inv('<mypermutation>') 返回[]。我错过了什么吗？ Python 是否因为某些我不理解的语法原因跳过了我的 while 循环？我对我认为的主题的 google 和 stackoverflow 搜索都没有返回任何有用的信息。

Answer 1

其他答案是正确的，但值得一提的是，使用 numpy 有一个性能更高的替代方案：

inverse_perm = np.argsort(permutation)

编辑：下面的第四个函数更快。

计时码：

def invert_permutation_list_scan(p):
    return [p.index(l) for l in range(len(p))]

def invert_permutation_list_comp(permutation):
    return [i for i, j in sorted(enumerate(permutation), key=lambda i_j: i_j[1])]

def invert_permutation_numpy(permutation):
    return np.argsort(permutation)

def invert_permutation_numpy2(permutation):
    inv = np.empty_like(permutation)
    inv[permutation] = np.arange(len(inv), dtype=inv.dtype)
    return inv

x = np.random.randn(1000)
perm = np.argsort(x)
permlist = list(perm)
assert np.array_equal(invert_permutation_list_scan(permlist), invert_permutation_numpy(perm))
assert np.array_equal(invert_permutation_list_comp(perm), invert_permutation_numpy(perm))
assert np.array_equal(invert_permutation_list_comp(perm), invert_permutation_numpy2(perm))
%timeit invert_permutation_list_scan(permlist)
%timeit invert_permutation_list_comp(perm)
%timeit invert_permutation_numpy(perm)
%timeit invert_permutation_numpy2(perm)

结果：

82.2 ms ± 7.28 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
479 µs ± 9.19 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
18 µs ± 1.17 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)
4.22 µs ± 388 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Answer 2

如果你只想要逆排列，你可以使用

def inv(perm):
    inverse = [0] * len(perm)
    for i, p in enumerate(perm):
        inverse[p] = i
    return inverse

perm = [3, 0, 2, 1]
print(inv(perm))
for i in perm:
    print(inv(perm)[i])

[1, 3, 2, 0]
0
1
2
3

Answer 3

我相信反转排列的最佳方法 perm 是

pinv = sorted(range(len(perm)), key=perm.__getitem__)

这避免了对.index() 的重复调用（如 SeF 的回答），这可能不是很有效（二次时间复杂度，而排序应该只需要 O(n log n)）。

但是请注意，无论输入是否是 {0,1,...,n-1} 的排列，这都会产生 {0,1,...n-1} 的排列} 或 {1,2,...,n} （后者是问题中所述）。如果输出应该是 {1,2,...,n} 的排列，则结果的每个元素都必须增加一个，例如，像这样：

pinv = [i+1 for i in sorted(range(len(perm)), key=perm.__getitem__)]

Answer 4

如果我有这个错误，请纠正我，但我认为当我将str 更改为列表时，我的代码出现了问题：str 是一个字符串，list(str) 是一个字符串元素列表。但是，由于字符串元素不能在数字上与数字进行比较，因此代码无法产生结果（[] 除外）。

Answer 5

“功能风格”版本：

def invert_permutation(permutation):
    return [i for i, j in sorted(enumerate(permutation), key=lambda (_, j): j)]

基本上，按排列中的值 j 对排列的索引 i 进行排序会产生所需的逆。

p = [2, 1, 5, 0, 4, 3]

invert_permutation(p)
# [3, 1, 0, 5, 4, 2]

# inverse of inverse = identity
invert_permutation(invert_permutation(p)) == p
# True

Answer 6

由于这里还没有人推荐它，我认为应该提到 SymPy 有一个 entire combinatorics module，有一个 Permutation 类：

from sympy.combinatorics import Permutation
o = [3, 0, 2, 1]
p = Permutation(o)
inv = p.__invert__()
print(inv.array_form) # [1, 3, 2, 0]

使用 SymPy 类可以让您访问大量其他有用的方法，例如比较等价排列与 ==。

您可以阅读sympy.combinatorics.Permutation源代码here。

除此之外，我会在此页面上使用np.arange 和argsort 推荐the answer。

Answer 7

也许有更短的方法：

def invert(p):
    return [p.index(l) for l in range(len(p))] 

这样：

perm = [3, 0, 2, 1]; print(invert(perm))

返回

[1,3,2,0]