10

フルセットをメモリに展開せずに、パワーセットの要素にインデックスを付けられるようにしたい (a la itertools)

さらに、インデックスをカーディナリティ順に並べたいと思います。したがって、インデックス 0 は空のセットである必要があり、インデックス 2**n - 1 はすべての要素である必要があります

私がこれまでに見つけたほとんどの文献は、電力セットを誘導的に生成することに関するものです。任意のインデックスに飛び込むことはできません。このインデックス作成の動機は、分散実行のために問題をスライスすることです。リモート マシンがクラスター間で反復子参照を共有することなく、どこにでも飛び込める場合に役立ちます。

編集:Blckknghtは、私が追求した解決策を提案しました。これは以下に示されています

from scipy.misc import comb

def kcombination_to_index(combination):
    index = 0
    combination = sorted(combination)
    for k, ck in enumerate(combination):
        index += comb(ck, k+1, exact=True)
    return index

def index_to_kcombination(index, k):
    result = []
    for k in reversed(range(1, k+1)):
        n = 0
        while comb(n, k, exact=True) <= index:
            n +=1
        result.append(n-1)
        index -= comb(n-1, k, exact=True)

    return result

class PowerSet:
    def __init__(self, elements):
        self.elements = elements

    def __len__(self):
        return 2 ** len(self.elements)

    def __iter__(self):
        for i in range(len(self)):
            yield self[i]

    def __getitem__(self, k):
        if not isinstance(k, int):
            raise TypeError
        #k=0 is empty set,
        #k= 1 - 1+n returns subsets of size 1
        for subset_size in range(len(self.elements) + 1):
            number_subsets = comb(len(self.elements), subset_size, exact=True)

            if k >= number_subsets:
                k -= number_subsets
            else:
                break

        #we now want the kth element of a possible permutation of subset_size elements
        indeces = index_to_kcombination(k, subset_size)

        return map(lambda i: self.elements[i], indeces)

if __name__ == "__main__":
    print "index of combination [8, 6, 3, 1, 0] is", kcombination_to_index([8, 6, 3, 1, 0])
    print "5 combination at position 72 is", index_to_kcombination(72,5)

    ps = PowerSet(["a", "b", "c", "d"])

    for subset_idx in range(len(ps)):
        print ps[subset_idx]
4

1 に答える 1

8

2段階のプロセスでこれを行うことができると思います。最初のステップは、Mihai Maruseac が彼の (現在は削除された) 回答で説明したように、適切なサイズが見つかるまで、可能なサイズを反復してセットのサイズを見つけることです。そのためのコードは次のとおりです。

def find_size(n, i):
    """Return a tuple, (k, i), where s is the size of the i-1'th set in the
       cardinally-ordered powerset of {0..n-1}, and i is the remaining index
       within the combinations of that size."""
    if not 0 <= i < 2**n:
        raise ValueError('index is too large or small')
    for k in range(n+1):
        c = comb(n, k)
        if c > i:
            return k, i
        else:
            i -= c

サイズを決定したら、組み合わせ番号システムを使用して、辞書編集順序から正しい k 組み合わせを見つけることができます。

def pick_set(n, i):
    """Return the i-1'th set in the cardinally-ordered powerset of {0..n-1}"""
    s, i = find_size(n, i)
    result = []
    for k in range(s, 0, -1):
        prev_c = 0
        for v in range(k, n+1):
            c = comb(v, k)
            if i < c:
                result.append(v-1)
                i -= prev_c
                break
            prev_c = c
    return tuple(result)

これらの関数は両方とも、サイズ n, n C kのセットの k-組み合わせの数を計算する関数を必要とします(私はこれを と呼びましたcomb)。この他の質問scipy.misc.combには、その値を見つけるための解決策がいくつか提案されていますgmpy.comb。または、順次増加する値 ( comb(n, 0)comb(n, 1)、などcomb(k, k)comb(k+1, k)、 など) で繰り返し呼び出されるため、代わりに、以前に計算された値を利用してパフォーマンスを向上させるインライン計算を使用できます。

使用例(上記のリンクされた質問のJF Sebastianの回答combから最小限に適合した関数を使用):

>>> for i in range(2**4):
        print(i, pick_set(4, i))

0 ()
1 (0,)
2 (1,)
3 (2,)
4 (3,)
5 (1, 0)
6 (2, 0)
7 (2, 1)
8 (3, 0)
9 (3, 1)
10 (3, 2)
11 (2, 1, 0)
12 (3, 1, 0)
13 (3, 2, 0)
14 (3, 2, 1)
15 (3, 2, 1, 0)

組み合わせを繰り返すことを計画している場合 (例で行ったように)、特定のサイズの次の組み合わせを見つけるためのより効率的なアルゴリズムがあるため、完全なアルゴリズムを実行するよりもおそらく効率的に行うことができます (ただし、初期サイズを使い果たしたときに、組み合わせの次の大きなサイズにバンプアップするには、少し追加のロジックが必要になります)。

編集:上で簡単に述べた最適化のいくつかの実装を次に示します。

nまず、範囲または値の組み合わせ値を効率的に計算するジェネレーターk:

def comb_n_range(start_n, stop_n, k):
    c = comb(start_n, k)
    yield start_n, c
    for n in range(start_n+1, stop_n):
        c = c * n // (n - k)
        yield n, c

def comb_k_range(n, start_k, end_k):
    c = comb(n, start_k)
    yield start_k, c
    for k in range(start_k+1, end_k):
        c = c * (n - k + 1) // k
        yield k, c

上記for ... in range(...): c = comb(...); ...のコードのビットは、これらを使用するように調整できます。これにより、少し速くなるはずです。

次に、辞書順で次の組み合わせを返す関数:

def next_combination(n, c):
    if c[-1] == n-len(c)+1:
        raise ValueError("no more combinations")
    for i in range(len(c)-1, -1, -1):
        if i == 0 or c[i] < c[i-1] - 1:
            return c[:i] + (c[i] + 1,) + tuple(range(len(c)-2-i,-1,-1))

そして、オブジェクトnext_combinationによって定義されたパワーセットから値の範囲を生成するために使用するジェネレーター:slice

def powerset_slice(n, s):
    start, stop, step = s.indices(2**n)
    if step < 1:
        raise ValueError("invalid step size (must be positive)")

    if start == 0:
        c = ()
    else:
        c = pick_set(n, start)

    for _ in range(start, stop, step):
        yield c
        for _ in range(step):
            try:
                c = next_combination(n, c)
            except ValueError:
                if len(c) == n:
                    return
                c = tuple(range(len(c), -1, -1))

.ではなくオブジェクト__getitem__が渡された場合、ジェネレーターを返すようにすることで、これを使用しているクラスに統合できます。これにより、本体を次のように変更するだけで高速化できます。sliceint__iter__return self[:]

于 2013-09-23T21:35:23.000 に答える