There are N blocks, numbered from 0 to N-1, arranged in a row. A couple of frogs were sitting together on one block when they had a terrible quarrel. Now they want to jump away from one another so that the distance between them will be as large as possible. The distance between blocks numbered J and K, where J ≤ K, is computed as K − J + 1. The frogs can only jump up, meaning that they can move from one block to another only if the two blocks are adjacent and the second block is of the same or greater height as the first. What is the longest distance that they can possibly create between each other, if they also chose to sit on the optimal starting block initially?
有 N 个块，编号从 0 到 N-1，排成一行。几只青蛙一起坐在一个街区，当它们发生了可怕的争吵时。现在他们想跳开彼此，以便他们之间的距离尽可能大。编号为 J 和 K 的块之间的距离（其中 J ≤ K）的计算公式为 K − J + 1。青蛙只能跳起来，这意味着只有当两个方块相邻并且第二个方块与第一个方块相同或更高的高度时，它们才能从一个方块移动到另一个方块。如果他们最初也选择坐在最佳起点上，他们之间可能创造的最远距离是多少？

Write a function:  编写一个函数：

function solution(blocks);

that, given an array blocks consisting of N integers denoting the heights of the blocks, returns the longest possible distance that two frogs can make between each other starting from one of the blocks.
给定一个由 N 个整数组成的数组 blocks ，表示块的高度，则返回两只青蛙从其中一个块开始彼此之间可以保持的最远可能距离。

Examples:  例子：

1. Given blocks = [2, 6, 8, 5], the function should return 3. If starting from blocks[0], the first frog can stay where it is and the second frog can jump to blocks[2] (but not to blocks[3]).
1. 给定区块 = [2， 6， 8， 5]，函数应返回 3。如果从方块[0]开始，第一只青蛙可以留在原地，第二只青蛙可以跳到方块[2]（但不能跳到方块[3]）。



2. Given blocks = [1, 5, 5, 2, 6], the function should return 4. If starting from blocks[3], the first frog can jump to blocks[1], but not blocks[0], and the second frog can jump to blocks[4].
2. 给定区块 = [1， 5， 5， 2， 6]，函数应返回 4。如果从方块[3]开始，第一只青蛙可以跳到方块[1]，但不能跳到方块[0]，第二只青蛙可以跳到方块[4]。



3. Given blocks = [1, 1], the function should return 2. If starting from blocks[1], the first frog can jump to blocks[0] and the second frog can stay where it is. Starting from blocks[0] would result in the same distance.
3. 给定 blocks = [1， 1]，函数应返回 2。如果从方块[1]开始，第一只青蛙可以跳到方块[0]，第二只青蛙可以留在原地。从 blocks[0] 开始会导致相同的距离。



Write an efficient algorithm for the following assumptions:
为以下假设编写一个高效的算法：

N is an integer within the range [2..200,000];
N 是 [2..200,000];
each element of array blocks is an integer within the range [1..1,000,000,000].
数组 blocks 的每个元素都是 [1..1,000,000,000]。

function solution(blocks) {
    // Implement your solution here
    let N = blocks.length
    let leftMax = new Array(N).fill(0)
    let rightMax = new Array(N).fill(0)

    for(let i=1;i<N;i++){
        if(blocks[i-1]>=blocks[i]){
            leftMax[i] = leftMax[i - 1] + 1;
        }
    }

    for(let i = N-2;i>=0;i--){
        if(blocks[i+1]<=blocks[i]){
            rightMax[i] = rightMax[i + 1]+1
        }
    }

    let maxDistance = 1
    for(let i=0;i<N;i++){
        const left = i - leftMax[i]
        const right = i + rightMax[i]
        maxDistance = Math.max(maxDistance, right-left+1)
    }
    return maxDistance
}

来自2024特斯拉笔试题