# Code logic is not clear

The logic in the code is not clear

int left = 0;

``````// the initial value for right index is the number of elements in the array

int right = nums.length;

// left + 1 >= right will finish while loop

while (left + 1 < right) {

int mid = (right + left) / 2;

if (nums[mid] == mid && left < nums[left]) {

// mid is the index to answer

return mid;
``````

Hello,

I hope you’re doing well.

This function is designed to find a “fixed point” in an array `nums`, which is an index `i` such that `nums[i] == i`. Here’s a step-by-step explanation of what the code does:

1. Initialize two variables:
• `left` to 0, indicating the leftmost index.
• `right` to the number of elements in the array, indicating the rightmost index.
2. Enter a `while` loop with the condition `left + 1 < right`, which means the loop continues until there are at least two elements to search between.
3. Inside the loop:
• Calculate the middle index `mid` as `(right + left) / 2`.
• Check if `nums[mid]` is equal to `mid` and `left` is less than `nums[left]`. If true, return `mid` because it’s the fixed point.
• If `nums[mid] < mid`, it means that we need to look for the fixed point in the right half of the array, so update `left = mid`.
• Otherwise, if `nums[mid] > mid`, it means we need to look for the fixed point in the left half of the array, so update `right = mid`.
4. After the loop, if `left` points to a fixed point (`nums[left] == left`), return `left`.
5. Also, if `right` is within the bounds of the array and it points to a fixed point (`nums[right] == right`), return `right`.
6. If no fixed point is found, return -1 to indicate that there’s no such element in the array.

The algorithm use binary search to locate the fixed point within the array, using the fact that the array is sorted and the target value (the index) exhibits a specific relationship with the values in the array.