trincot

这是因为如果 memo 是空的,递归需要一直到 n <= 2 .所以如果你马上打第一个电话 fib(1000) 您可能会遇到堆栈溢出。

然而,当你从较小的值开始,比如 fib(10) , 备忘录 将收集大量结果,包括 10 和 9 .因此,下次你打电话增加你通过的论点时,它不必一直重复到2,但当它达到9或10时,它已经可以回溯,因为它会发现它在 备忘录 .

注意 备忘录 仅首字母缩写为 {} 目前该功能正在运行 定义 ,因此您只需不断扩展它,从而减少使用调用堆栈进行深层递归的需要。

问题在于 partition 在循环体中:

                if i == None:
                    i = left
                else:
                    i = i.next
                    i.data, j.data = j.data, i.data

互换也应该在未来几年进行 if 所以应该把它移出 else 街区:

                if i == None:
                    i = left
                else:
                    i = i.next
                i.data, j.data = j.data, i.data

您应该避免代码重复:只在一个地方执行交换。避免重新计算 2 * i + 1 好几次。是的,减少你检查的条件数量。只需检查两个子项(如果有两个)中哪一个值最小,然后进行比较 那个 使用父对象的值。就这样。

其他一些评论:

• 我不会将数组的长度存储在属性中,因为这样一来,每次从堆中推送或提取值时,都会有更新数组的开销。
• 不需要执行对数和幂运算。只需计算最后一个节点的父节点在哪里。最后一个节点位于索引处 len()-1 ,所以它的父母在 (len()-1-1)//2 这就是 len()//2-1 .
• 这个 while 状况 sift_down 不应该重复你将要做的检查 sift_down_level .只需验证返回值不是-1。
• 打电话 heapify 在初始化过程中

在不对您的设计进行其他更改的情况下,我们可以得到以下结果:

class MinHeap:
    def __init__(self, arr):
       self.arr = arr
       self.heapify()

    def heapify(self):
        for i in range(len(self.arr) // 2 - 1, -1, -1):
            self.sift_down(i)

    def sift_down(self, i):
        while i != -1:
            i = self.sift_down_level(i)

    def sift_down_level(self, i):
        child = i * 2 + 1
        if child < len(self.arr):
            if child + 1 < len(self.arr) and self.arr[child + 1] < self.arr[child]:
                child += 1
            if self.arr[child] < self.arr[i]:
                self.arr[child], self.arr[i] = self.arr[i], self.arr[child]
                return child
        return -1

首先确保 b 这不是消极的。如果是,翻转两个标志。然后使用 abs(a) 在 range .

你的代码也应该初始化 gcf 为1,因为循环可能不会进行迭代(即 a 是0)。就像那时一样 gcf 已经是1了,你最好从2开始循环。

另外,不要在这样的函数中执行I/O;始终将I/O与算法逻辑分开。执行功能之外的I/O任务。

以下是它的工作原理:

def fraction(a, b):
    if b < 0:
        a = -a
        b = -b
    gcf = 1
    for i in range(2, min(abs(a), b) + 1):
        if a % i == 0 and b % i == 0:
            gcf = i
    return a//gcf, b//gcf


a = int(input("Enter the value of a "))
b = int(input("Enter the value of b "))
a, b = fraction(a, b)
print(a, "/", b)

请注意,有 more efficient algorithms 获得最大公约数。

不应将日期和时间作为单独的字段存储在数据库中。你应该把它们组合成一个 datetime 数据库中的字段。然后,您应该在 supported literal formats YYYY-MM-DD H:m:s

现在回到你原来的处境。问题是,当表的日期严格地介于两个极端日期之间(不等于两个极端日期中的任何一个)时,还需要时间条件。在这种情况下,时间部分应该没有限制:在这样的日子里,所有的时间都是可以的。

下面是SQL的外观:

SELECT     * 
FROM       metingen 
WHERE      ( Datum > '$q'  OR ( Datum = '$q'  AND Tijd >= '$q2' ) )
      AND  ( Datum < '$q1' OR ( Datum = '$q1' AND Tijd <= '$q3' ) )
ORDER BY   Id DESC

但同样,这不是最佳做法。

varchar (不是 date D-M-YYYY 格式,而您的输入是 DD-MM-YYYY

SELECT     * 
FROM       metingen 
WHERE      ( STR_TO_DATE(Datum, '%d-%m-%Y') > STR_TO_DATE('$q', '%d-%m-%Y') 
                  OR ( STR_TO_DATE(Datum, '%d-%m-%Y') = STR_TO_DATE('$q', '%d-%m-%Y')   
                       AND Tijd >= '$q2' ) )
      AND  ( STR_TO_DATE(Datum, '%d-%m-%Y') < STR_TO_DATE('$q1', '%d-%m-%Y')
                  OR ( STR_TO_DATE(Datum, '%d-%m-%Y') = STR_TO_DATE('$q1', '%d-%m-%Y') 
                       AND Tijd <= '$q3' ) )
ORDER BY   Id DESC

另一个问题是,您插入发布到页面的字符串,因此它们是用户驱动的。这表示 SQL Injection vulnerabilty . 相反,你应该使用 prepared statements 并将日期时间字符串作为参数传递。

您可以选择一些算法来确定一个种子,该种子可以从列表本身派生,而不依赖于其顺序。

例如,对于示例数据结构,seed可以是所有值的总和。然后使用这个种子,您将生成一个从0到n-1的随机(但确定性)数字排列。这种排列可以用作shuffle和unshuffle函数的基础:

import random

def getperm(l):
    seed = sum(sum(a) for a in l)
    random.seed(seed)
    perm = list(range(len(l)))
    random.shuffle(perm)
    random.seed() # optional, in order to not impact other code based on random
    return perm

def shuffle(l):
    perm = getperm(l)
    l[:] = [l[j] for j in perm]

def unshuffle(l):
    perm = getperm(l)
    res = [None] * len(l)
    for i, j in enumerate(perm):
        res[j] = l[i]
    l[:] = res

示例调用:

l=[(1,2),(3,4),(5,6),(7,8),(9,10)]   
print(l)    
shuffle(l)
print(l) # shuffled
unshuffle(l)
print(l)  # the original