C# 获取n'；th整数>；0，设置了最多k位？

我有一个系列，值大于0，其中设置的位数不超过

k

for instance, for `k = 2`

n    binary    value    bits_set
0    0000      0        0
1    0001      1        1
2    0010      2        1
3    0011      3        2
4    0100      4        1
5    0101      5        2
6    0110      6        2
7    1000      8        1
8    1001      9        2
9    1010      10       2
10   1100      14       2
... etc ...

对于给定的

k

，是否有一种计算效率高的方法来查找序列中的

n

项

---

我所有的尝试都表现得非常缓慢，我不知道如何有效地解决这个问题。

我知道这个问题被标记为C，很抱歉用Python给出了答案：

首先，我们将找到一种方法，用可用空间中的某个位数来计算有多少个不同的数字。然后我们将找到一种排序这些结果的方法

表示f（b，s）为用b集合中的s位构造一个数的方法的数目

这里有一个递归关系。一个满足f（b，s）的数要么是满足f（b-1，s）且前面有0的数，要么是满足f（b-1，s-1）且前面有1的数。因此f（b，s）=f（b-1，s）+f（b-1，s-1）

一些基本情况填写在该表中： f（b，0）是1 f（b，s）是1，其中b=s

    10 9 8 7 6 5 4 3 2 1 0
24   . . . . . . . . . . 1
23   . . . . . . . . . . 1
22   . . . . . . . . . . 1
21   . . . . . . . . . . 1
20   . . . . . . . . . . 1
19   . . . . . . . . . . 1
18   . . . . . . . . . . 1
17   . . . . . . . . . . 1
16   . . . . . . . . . . 1
15   . . . . . . . . . . 1
14   . . . . . . . . . . 1
13   . . . . . . . . . . 1
12   . . . . . . . . . . 1
11   . . . . . . . . . . 1
10   1 . . . . . . . . . 1
 9   0 1 . . . . . . . . 1
 8   0 0 1 . . . . . . . 1
 7   0 0 0 1 . . . . . . 1
 6   0 0 0 0 1 . . . . . 1
 5   0 0 0 0 0 1 . . . . 1
 4   0 0 0 0 0 0 1 . . . 1
 3   0 0 0 0 0 0 0 1 . . 1
 2   0 0 0 0 0 0 0 0 1 . 1
 1   0 0 0 0 0 0 0 0 0 1 1

构建表g（b，s）也很有用，它表示有多少个b位数字设置了s或更少的位。g（b，s）=和（i=0到s）f（b，i）

所以我们现在可以回答这个问题，有多少个数字正好是从24位开始的10位，即f（24，10）=1961256，我们可以回答有多少个数字最多是从24位开始的10位，即f（24，10）+f（24，9）+f（24，8）…+f（24，1）+f（24，0）=g（24，10）=4540386

但是，如果问题是找到第n个数字，这样24位中最多设置10位，我们需要能够以有序的方式搜索这个空间

首先，请注意，第一个1位于第n位的任何数字都比第一个1位于n之后的任何数字大

---

这意味着我们可以找到每个数字的位置，只需一个位集后跟z零。这必然大于g（z，max（z，10））。我们可以在这里插入一个优化并声明，由于10位空间中的所有数字都是合格的（它们不可能有超过10位的集合），那么对于所有的n2^10（>z>10），第n个这样的数字=n，我们可以通过查找最大的z_10来搜索第一个集合位的位置，这样g（z_10，10）“第n个数字”意味着什么？有许多最多设置了M位的数字。您正在寻找最小的一个？我是指索引运算符eg array[n]。请编辑您的问题以包含该信息并指定数字的条件。正如我所说，有很多数字满足这个条件。你在分类吗？数组和什么有什么关系？不，它最多需要设置M位。我真的看不懂python，你能给我一个简单的方法来回答我的代码问题吗。

class Memoize:
    def __init__(self, f):
        self.f = f
        self.memo = {}
    def __call__(self, *args):
        if not args in self.memo:
            self.memo[args] = self.f(*args)
        return self.memo[args]

def g(b, s):
    r = 0
    for i in range(0, s+1):
        r = r + f(b, i)
    return r

def f(b,s):
    if b == s:
        return 1
    if s == 0:
        return 1
    if b < s:
        return 0
    return f(b-1, s) + f(b-1, s-1)

def build(s, n, i):
    d = (24 - len(s))
    if n <= 2 ** i:
        return s + format(n, '0%db' % (d))
    for z in range(i, d+1):
        x = g(z, i)
        if x < n:
            continue
        if x == n:
            return s + format(2 ** z, '0%db' % (d))
        y = g(z-1, i)
        return build(s + format(1, '0%db' % (d-(z-1))),
                     n - y,
                     i - 1)

def solve(n):
    return build("", n-1, 10)

f = Memoize(f)
g = Memoize(g)

for n in range(1, 4540387):
    print("%07d: %s" % (n, solve(n)))