给第3到第7天都加5，为什么只改两个格子就够了？

"""Batch range increments on integer arrays; half-open ranges [left, right)."""
from itertools import product


def require(condition, message):
    if not condition:
        raise AssertionError(message)


class RangeAdds:
    def __init__(self, values):
        if not isinstance(values, (list, tuple)):
            raise TypeError("list or tuple required")
        if len(values) > 10000 or any(type(x) is not int for x in values):
            raise ValueError("at most 10000 integer entries; bool is not accepted")
        self.n = len(values)
        self.diff = [0] * (self.n + 1)
        previous = 0
        for i, value in enumerate(values):
            self.diff[i] = value - previous
            previous = value
        self.diff[self.n] = -previous  # Return to zero just beyond the array.

    def add(self, left, right, delta):
        if any(type(x) is not int for x in (left, right, delta)):
            raise TypeError("integer bounds and delta required")
        if not 0 <= left <= right <= self.n:
            raise ValueError("require 0 <= left <= right <= n")
        self.diff[left] += delta
        self.diff[right] -= delta  # Same cell cancels when left == right.

    def materialize(self):
        total, values = 0, []
        for i in range(self.n):
            total += self.diff[i]
            values.append(total)
        return values  # Do not overwrite the stored difference array.


def oracle(values, updates):
    result = list(values)
    for left, right, delta in updates:
        for i in range(left, right):
            result[i] += delta
    return result


def main():
    original = [2, 1, 3, 0, 2, 4, 1]
    updates = [(2, 7, 5), (4, 6, -2), (7, 7, 9)]
    demo = RangeAdds(original)
    print(f"initial={original}; diff={demo.diff}")
    for update in updates:
        demo.add(*update)
        print(f"add{update}; diff={demo.diff}; values={demo.materialize()}")
    require(demo.materialize() == [2, 1, 8, 5, 5, 7, 6], "demo")
    require(original == [2, 1, 3, 0, 2, 4, 1], "input was changed")
    arrays, single_updates, paired_updates = 0, 0, 0
    for n in range(6):
        for values in product((-1, 0, 2), repeat=n):
            arrays += 1
            tree = RangeAdds(values)
            require(tree.materialize() == list(values), "initial reconstruction")
            for left in range(n + 1):
                for right in range(left, n + 1):
                    for delta in (-2, 0, 3):
                        tree.add(left, right, delta)
                        expected = oracle(values, [(left, right, delta)])
                        require(tree.materialize() == expected, "single update")
                        require(sum(tree.diff) == 0, "end sentinel")
                        tree.add(left, right, -delta)
                        require(tree.materialize() == list(values), "inverse update")
                        single_updates += 1
    for n in range(5):
        base = [i - 2 for i in range(n)]
        operations = [(l, r, d) for l in range(n + 1)
                      for r in range(l, n + 1) for d in (-2, 3)]
        for first, second in product(operations, repeat=2):
            expected = oracle(base, [first, second])
            for ordered in [(first, second), (second, first)]:
                tree = RangeAdds(base)
                for operation in ordered:
                    tree.add(*operation)
                require(tree.materialize() == expected, "overlap or order")
            paired_updates += 1
    isolated = [1, 2]
    snapshot = RangeAdds(isolated)
    isolated[0] = 99
    returned = snapshot.materialize()
    returned[0] = 88
    require(snapshot.materialize() == [1, 2], "snapshot alias")
    invalid = [lambda: RangeAdds(iter([1])), lambda: RangeAdds([True]),
               lambda: RangeAdds([0] * 10001), lambda: demo.add(-1, 2, 1),
               lambda: demo.add(4, 3, 1), lambda: demo.add(0, 8, 1),
               lambda: demo.add(0, 2, 1.0), lambda: demo.add(False, 2, 1)]
    rejected = 0
    before = demo.diff.copy()
    for action in invalid:
        try:
            action()
        except (TypeError, ValueError):
            rejected += 1
        else:
            raise AssertionError("invalid input accepted")
    require(demo.diff == before, "rejected operation changed state")
    print(f"initial_arrays={arrays}; single_updates={single_updates}; paired_updates={paired_updates}")
    print(f"reversed_pair_checks={paired_updates}; rejected_inputs={rejected}; snapshot_isolation=PASS")
    print("PASS")


if __name__ == "__main__":
    main()