Question

我正在尝试创建一种算法以某种方式生成十进制数。

a）我的初始号码为i = 2.

b）然后我有一个增量添加方法，比如f(n) { n * 2 }。

c）然后我有一个数字说l = 2的插槽长度，它为小数字创建前零，并限制更长数字的最大长度。 2变为02，64为64，但512 = (5)12 5在前一个广告位上向后移动

d）最大插槽是第四个参数m = 10

e）最后，我想通过对插槽中的数字求和并将其用作0的小数部分来计算值。

所以举个例子：

i=2
f(n)=n*2
l=2
m=10

应以这种方式产生结果：

步骤1）

02 04 08 16 32 64 128 256 512 1024

第2步）

02 04 08 16 32 64
                1 28
                   2 56
                      5 12
                        10 24

- ＆GT;

slot:     1  2  3  4  5  6  7  8  9  10
computed: 02 04 08 16 32 65 30 61 22 24

第3步）

我有一个数字：02040816326530612224或0.02040816326530612224，如e）部分所述。

请注意，如果此示例中的最大广告位数较大，则广告位9和10上的数字会发生变化。我也希望将b）部分作为一个函数，因此我可以将其更改为fib(nx) {n1+n2}之类的其他函数。

我更喜欢Python作为算法的计算机语言，但任何易于转换为Python的东西都是可以接受的。

ADDED

这是我迄今为止设法创建的一个功能：

# l = slot length, doesnt work with number > 2...
def comp(l = 2):

    a = []
    # how to pass a function, that produces this list?
    b = [[0, 2], [0, 4], [0, 8], [1, 6], [3, 2], [6, 4], [1, 2, 8], [2, 5, 6], [5, 1, 2], [1, 0, 2, 4], [2, 0, 4, 8]]

    r = 0
    # main algo
    for bb in b:
        ll = len(bb)
        for i in range(0, ll):
            x = r + i - ll + l
            # is there a better way to do following try except part?
            try:
                a[x] += bb[i]
            except IndexError:
                a.append(bb[i])
            # moving bits backward, any better way to do this?
            s = a[x] - 9
            d = 0
            while s > 0:
                d += 1
                a[x] -= 10
                a[x-d] += 1
                s = a[x-d] - 9
        r += l

    return '0.' + ''.join(map(str, a))

Answer 1

def doub(n):
    return pow(2, n)

def fibo(n):
    a, b = 0, 1
    for i in range(n):
        a, b = b, a + b
    return a

def fixed_slot_numbers(f, l, m):
    b = []
    for n in range(1, m):
        a = [int(c) for c in str(f(n))]
        while len(a) < l:
            a.insert(0, 0)
        b.append(a)
    return b

def algo(function, fixed_slot_length = 2, max_slots = 12):
    a = []
    slot_numbers = fixed_slot_numbers(function, fixed_slot_length, max_slots)
    for r, b in enumerate(slot_numbers):
        r *= fixed_slot_length
        slot_length = len(b)
        for bidx in range(0, slot_length):
            aidx = r + bidx - slot_length + fixed_slot_length
            try:
                a[aidx] += b[bidx]
            except IndexError:
                a.append(b[bidx])
            d = 0
            while a[aidx-d] > 9:
                a[aidx-d] -= 10
                d += 1
                a[aidx-d] += 1
    return '0.%s' % ''.join(map(str, a))


algo(doub, 2, 28) -> 0.020408163265306122448979591836734693877551020405424128 = 1/49

algo(fibo, 1, 28) -> 0.112359550561797752808950848 = 10/89

基于时隙长度求和的十进制扩展

1 个答案: