# AI solution for JavaScript Coding Question on BFE.dev

51. search element right after target with Binary Search(possible duplicate array)

To solve this problem with Binary Search, we need to modify the Binary Search algorithm to keep searching even after we find the target. When we find the target, we need to keep searching to the right of it until we find the last occurrence of the target. Once we find the last occurrence, the element to the right of it is the answer. Here is the solution:

```
/**
* @param {number[]} nums - sorted ascending array with possible duplicates
* @param {number} target
* @return {number|undefined}
*/
function searchElement(nums, target) {
let left = 0;
let right = nums.length - 1;
let lastAppearance = -1;
while (left <= right) {
const mid = Math.floor((left + right) / 2);
if (nums[mid] === target) {
lastAppearance = mid;
left = mid + 1; // search to the right of mid for last appearance
} else if (nums[mid] < target) {
left = mid + 1;
} else {
right = mid - 1;
}
}
if (lastAppearance !== -1 && lastAppearance < nums.length - 1) {
return nums[lastAppearance + 1];
} else {
return undefined;
}
}
```

We start by initializing `left`

and `right`

pointers to the first and last indices of the array, respectively. We also initialize `lastAppearance`

to -1 to indicate that we haven't found the target yet.

We use a standard Binary Search algorithm to search for the target. When we find the target, we update `lastAppearance`

to the current index and continue searching to the right of the current index by updating `left`

to `mid + 1`

.

Once the Binary Search is complete, we check if we found the target at all and whether there is an element to the right of the last appearance. If both conditions are true, we return the element to the right of the last appearance. Otherwise, we return `undefined`

.

The time complexity of this solution is O(log n) and the space complexity is O(1).