You are given an array of positive integers nums.

A Fibonacci array is a contiguous sequence in which every element from the third position onward equals the sum of the two elements immediately before it. In other words, for every valid index i starting from the third element, the condition nums[i] = nums[i-1] + nums[i-2] must hold.

Your task is to return the length of the longest Fibonacci subarray within nums.

Key points to understand:

• A subarray is a contiguous (unbroken) portion of the original array — you cannot skip or rearrange elements.
• Any subarray of length 1 or 2 automatically counts as a Fibonacci array, since the "sum of the two preceding terms" rule only applies starting from the third element. This guarantees the answer is always at least 2 when the array has two or more elements.
• The Fibonacci property here refers to the structure of the sequence (each term being the sum of the previous two), not to the classic Fibonacci numbers themselves. For example, [4, 7, 11, 18] is a valid Fibonacci subarray because 11 = 4 + 7 and 18 = 7 + 11.

Example walkthrough:

Suppose nums = [1, 1, 1, 1, 2, 3, 5, 1]:

• The subarray [1, 1, 2, 3, 5] satisfies the rule: 2 = 1 + 1, 3 = 1 + 2, 5 = 2 + 3.
• Its length is 5, which would be the answer since no longer contiguous segment satisfies the condition.

The goal is simply to scan the array and find the longest stretch of consecutive elements where this "each term equals the sum of the previous two" relationship holds without interruption.

The first thing to notice is that the Fibonacci condition is a local property: whether nums[i] extends a Fibonacci subarray depends only on its two immediate neighbors, nums[i-1] and nums[i-2]. We never need to look further back than two positions to make a decision.

This observation leads to a natural way of thinking about the problem: as we walk through the array from left to right, at each position we ask a simple yes/no question — does nums[i] == nums[i-1] + nums[i-2]?

• If yes, the current element seamlessly continues whatever Fibonacci streak was already running. The streak grows by exactly one.
• If no, the chain is broken at this point. But it does not reset to zero — since any two adjacent elements always form a valid Fibonacci subarray, the new streak ending at nums[i] starts fresh with length 2 (the pair nums[i-1], nums[i]).

This is essentially a "longest run" pattern, similar to finding the longest streak of increasing elements: maintain a running counter f representing the length of the longest valid subarray ending at the current index, extend it when the condition holds, reset it when it fails, and track the maximum value seen along the way in ans.

A key insight is why a single break forces a full reset to 2 rather than some partial recovery: a Fibonacci subarray is fully determined by its first two elements. Once the condition fails at position i, no subarray containing both nums[i-2] and nums[i] through that point can ever be Fibonacci, so the only candidates going forward must begin at nums[i-1] or later. Starting the counter at 2 captures exactly that.

Because each element is examined once with constant work, this greedy single-pass scan runs in O(n) time and O(1) space — there is no need for nested loops or storing intermediate subarrays, since the local nature of the condition guarantees we never miss a longer answer.

The implementation follows a dynamic programming pattern, simplified down to a single rolling variable since each state only depends on the previous one.

State definition:

Let f represent the length of the longest Fibonacci subarray ending at the current index. The final answer ans is the maximum value f ever reaches during the scan.

Step-by-step walkthrough:

1. Initialization:

   n = len(nums)
   ans = f = 2

   Both ans and f start at 2, because any pair of adjacent elements is automatically a valid Fibonacci subarray. This also handles the base case before any checking begins.

2. Traverse from index 2:

   for i in range(2, n):

   The Fibonacci condition needs two preceding elements, so the first index worth checking is 2.

3. State transition: for each i, apply one of two rules:

   • Extend the streak — if nums[i] == nums[i-1] + nums[i-2], the current element continues the Fibonacci subarray ending at i-1:

     f = f + 1
     ans = max(ans, f)

     This corresponds to the transition f[i] = f[i-1] + 1. The answer is updated immediately, so no separate pass is needed.

   • Reset the streak — otherwise, the chain breaks, and the longest Fibonacci subarray ending at i is just the pair (nums[i-1], nums[i]):

     f = 2

4. Return the result:

   return ans

Why a single variable suffices:

A full DP formulation would store an array f[i] for every index. However, the transition for f[i] only ever reads f[i-1], so the entire array can be compressed into one scalar — a classic space optimization for linear-recurrence DP.

Trace example with nums = [1, 1, 2, 3, 5, 4]:

The result is 5, matching the subarray [1, 1, 2, 3, 5].

Complexity analysis:

• Time complexity: O(n), where n is the length of nums. Each element is visited exactly once, and each visit performs constant-time work (one addition, one comparison, and possibly a max).
• Space complexity: O(1). Only two integer variables (f and ans) are maintained regardless of input size.