# Solving Leetcode Interviews in Seconds with AI: Element Appearing More Than 25% In Sorted Array


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1287" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given an integer array sorted in non-decreasing order, there is exactly one integer in the array that occurs more than 25% of the time, return that integer.   Example 1:  Input: arr = [1,2,2,6,6,6,6,7,10] Output: 6  Example 2:  Input: arr = [1,1] Output: 1    Constraints:  1 <= arr.length <= 104 0 <= arr[i] <= 105  

	# Explanation
	Here's a solution to the problem of finding the integer that occurs more than 25% of the time in a sorted array:

*   **Key Idea:** Exploit the sorted nature of the array. We don't need to count every element. We only need to check strategically placed elements to see if their frequency exceeds 25%.
*   **Sampling:** Check elements at approximately 25%, 50%, and 75% positions in the array. If any of these occur more than 25% of the time, it will be our answer.
*   **Frequency Check:** For the sampled element, perform a binary search to find the first and last occurrence to determine its frequency and verify if it meets the >25% criteria.

*   **Runtime Complexity:** O(log n), where n is the length of the array.  **Storage Complexity:** O(1).

	
	# Code
	```python
	def findSpecialInteger(arr: list[int]) -> int:
    n = len(arr)
    if n == 1:
        return arr[0]

    candidates = [arr[n // 4], arr[n // 2], arr[3 * n // 4]]

    for candidate in candidates:
        first = -1
        low = 0
        high = n - 1
        while low <= high:
            mid = (low + high) // 2
            if arr[mid] == candidate:
                first = mid
                high = mid - 1
            elif arr[mid] < candidate:
                low = mid + 1
            else:
                high = mid - 1
        
        last = -1
        low = 0
        high = n - 1
        while low <= high:
            mid = (low + high) // 2
            if arr[mid] == candidate:
                last = mid
                low = mid + 1
            elif arr[mid] < candidate:
                low = mid + 1
            else:
                high = mid - 1

        if last - first + 1 > n / 4:
            return candidate

    return -1  # Should not happen based on problem description
	```