Question

我需要制作一个函数power（x，n），以n / 2个步长来计算x ^ n。

我制作了一个可以在n步内计算功效的递归函数：

var sourceBuffer;
var queue = [];
var mediaSource = new MediaSource();
mediaSource.addEventListener('sourceopen', sourceOpen, false);
main();

socket.on('stream', data => {
    if (mediaSource.readyState == "open") {
        if (sourceBuffer.updating || queue.length > 0) {
            queue.push(data.video);
        } else {
            sourceBuffer.appendBuffer(data.video);
        }
    }
});

function main() {
    videoElement = document.querySelector('#video');
    videoElement.src = URL.createObjectURL(mediaSource);
}

function sourceOpen(e) {
    console.log('open');
    sourceBuffer = mediaSource.addSourceBuffer('video/webm; codecs="opus, vp9"');
    sourceBuffer.addEventListener('updateend', () => {
        console.log(sourceBuffer.updating, mediaSource.readyState);

        if (queue.length > 0 && !sourceBuffer.updating) {
            sourceBuffer.appendBuffer(queue.shift());
        }
    });
}

但是，我需要将所需步骤减少一半（为n / 2）。我想我需要使用“快速启动”功能，但我不知道如何使用递归来实现。

感谢您的帮助。

Answer 1

当偶数分为两部分时，您可以根据偶数或奇数来拆分数字：

def simple_recursive_power(x, n):
    if n == 0:
        return 1

    if n % 2:
        return x * simple_recursive_power(x, n - 1)
    else:
        m = simple_recursive_power(x, n // 2)
        return m * m

Answer 2

我把我的第一个答案放在末尾，我的第一个答案毫无意义。我一直在研究renac的答案，这样做是最好的递归方法。而且我不知道为什么要使用递归：

def simple_recursive_power(x, n):
    if n == 0:
        return 1
    if n % 2:
        return x * simple_recursive_power(x, n - 1)
    else:
        m = simple_recursive_power(x, n // 2)
        return m * m


start = time.time()
a =simple_recursive_power(11, 5000000)
end = time.time()
print((end - start), ' s')


def simple_recursive_power(x, n):
    if n == 0:
        return 1
    if n % 4:
        return x * simple_recursive_power(x, n - 1)
    else:
        m = simple_recursive_power(x, n // 4)
        return m * m * m * m

start = time.time()
b = simple_recursive_power(11, 5000000)
end = time.time()
print((end - start), ' s')

start = time.time()
c = 11**5000000
end = time.time()
print((end - start), ' s')

结果是：

3.190255641937256 s
5.789834022521973 s
3.141327142715454 s

11**5000000 更容易理解，比递归还快，为什么不使用它呢？

是因为某些处理器体系结构可以与递归一起很好地工作吗？

唯一的方法必须是用于多处理或线程化！

我的第一个答案：

我不明白要点，但是..这应该有效：

def simple_recursive_power(x, n):
    if n == 0:
        return 1
    elif n == 1:
        return x
    return x * x * simple_recursive_power(x, n - 2)

编辑： n / 3步：

def simple_recursive_power(x, n):
    if n == 0:
        return 1
    elif n == 1:
        return x
    elif n == 2:
        return x * x
    return x * x * x simple_recursive_power(x, n - 3)

进行有效的递归幂函数

2 个答案: