排列列表的有序排名

Question

我正在尝试开发一种方法来查找以下列表中特定序列的有序等级。

a = list(sorted(itertools.combinations(range(0,5),3)))
b = list(sorted(itertools.permutations(range(0,5),3)))

a 表示combinatorial number system 的元素列表，因此排名公式非常简单。

我需要的是 2 个函数 magic_rank_1 和 magic_rank_2，它们具有以下定义

def magic_rank_1(perm_item,permutation_list_object): 
## permutation_list_object is actually b
    return list_object.index(perm_item)

def magic_rank_2(perm_item,permutation_list_object,combination_list_object):
## permutation_list_object is actually b and combination_list_object is actually a
    return combination_list_object.index(tuple(sorted(perm_item)))

所以基本上magic_rank_2((0,1,2),b,a) = magic_rank_2((2,0,1),b,a)

听起来很简单……但我有一些限制。

• 我无法使用 indexof 函数，因为我无法为每个项目搜索 >100000000 个项目
• 我需要 magic_rank_1 和 magic_rank_2 是纯数学的，而不使用任何排序函数或比较函数或搜索函数。我将拥有的所有信息是需要识别其等级的元组和我的字母表的最后一个字母（在本例中为 5）
  • 当 k = len(a) 时，magic rank 2 不必是 0 到 k-1 之间的数字，只要它是 0 到 2 之间的唯一数字即可^(ceiling((max_alphabet/2)+1))

我知道magic_rank_1 可以通过类似于this 的东西来计算，但有区别，输入字母表的每个字母都被使用，在我的情况下它是一个子集

最后是的，这应该是散列函数的替代品，目前正在使用散列函数，但我没有利用 magic_rank_2((0,1,2),b,a) = magic_rank_2((2,0,1),b,a) 的事实。如果可以的话，它将显着减少我的存储空间需求，因为我的序列长度实际上是 5 ，所以如果我可以计算一个 magic_rank_2 的方法，我会将我的存储需求减少到当前需求的 1%

更新 - 对于magic_rank_2，元组的元素之间应该没有比较操作，即没有排序、最小值、最大值等

这只会使算法的效率低于常规散列

Answer 1

以下两个函数将对组合和排列进行排名，给定一个单词和一个字母表（或者在您的情况下，一个元组和一个列表）。

import itertools
import math

def rank_comb(word, alph, depth=0):
    if not word: return 0

    if depth == 0:
        word = list(word)
        alph = sorted(alph)

    pos = 0
    for (i,c) in enumerate(alph):
        if c == word[0]:
            # Recurse
            new_word = [x for x in word if x != c]
            new_alph = [x for x in alph if x > c]
            return pos + rank_comb(new_word, new_alph, depth+1)
        else:
            num = math.factorial(len(alph)-i-1)
            den = math.factorial(len(alph)-i-len(word)) * math.factorial(len(word)-1)
            pos += num // den


def rank_perm(word, alph, depth=0):
    if not word: return 0

    if depth == 0:
        word = list(word)
        alph = sorted(alph)

    pos = 0
    for c in alph:
        if c == word[0]:
            # Recurse
            new_word = [x for x in word if x != c]
            new_alph = [x for x in alph if x != c]
            return pos + rank_perm(new_word, new_alph, depth+1)
        else:
            num = math.factorial(len(alph)-1)
            den = math.factorial(len(alph)-len(word))
            pos += num // den


#== Validation =====================================================================
# Params
def get_alph(): return range(8)
r = 6

a = list(sorted(itertools.combinations(get_alph(), r)))
b = list(sorted(itertools.permutations(get_alph(), r)))

# Tests
PASS_COMB = True
PASS_PERM = True
for (i,x) in enumerate(a):
    j = rank_comb(x, get_alph())
    if i != j:
        PASS_COMB = False
        print("rank_comb() FAIL:", i, j)

for (i,x) in enumerate(b):
    j = rank_perm(x, get_alph())
    if i != j:
        PASS_PERM = False
        print("rank_perm() FAIL:", i, j)

print("rank_comb():", "PASS" if PASS_COMB else "FAIL")
print("rank_perm():", "PASS" if PASS_PERM else "FAIL")

功能大同小异，区别不大：

• new_alph 的过滤方式不同。
• num 和den 的计算方式不同。

更新：

rank_comb2 不需要对输入词进行排序（一个三元组）：

import itertools
import math

def rank_comb2(word, alph, depth=0):
    if not word: return 0

    if depth == 0:
        word = list(word)
        alph = sorted(alph)

    pos = 0
    for (i,c) in enumerate(alph):
        if c == min(word):
            # Recurse
            new_word = [x for x in word if x != c]
            new_alph = [x for x in alph if x > c]
            return pos + rank_comb2(new_word, new_alph, depth+1)
        else:
            num = math.factorial(len(alph)-i-1)
            den = math.factorial(len(alph)-i-len(word)) * math.factorial(len(word)-1)
            pos += num // den

r1 = rank_comb2([2,4,1], range(5))
r2 = rank_comb2([1,4,2], range(5))
r3 = rank_comb2([4,1,2], range(5))

print(r1, r2, r3)     # 7 7 7