<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> and an integer <code>k</code>.</p>

<p>You can perform the following operation on the array <strong>at most</strong> <code>k</code> times:</p>

<ul>
	<li>Choose any index <code>i</code> from the array and <strong>increase</strong> or <strong>decrease</strong> <code>nums[i]</code> by <code>1</code>.</li>
</ul>

<p>The score of the final array is the <strong>frequency</strong> of the most frequent element in the array.</p>

<p>Return <em>the <strong>maximum</strong> score you can achieve</em>.</p>

<p>The frequency of an element is the number of occurences of that element in the array.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,2,6,4], k = 3
<strong>Output:</strong> 3
<strong>Explanation:</strong> We can do the following operations on the array:
- Choose i = 0, and increase the value of nums[0] by 1. The resulting array is [2,2,6,4].
- Choose i = 3, and decrease the value of nums[3] by 1. The resulting array is [2,2,6,3].
- Choose i = 3, and decrease the value of nums[3] by 1. The resulting array is [2,2,6,2].
The element 2 is the most frequent in the final array so our score is 3.
It can be shown that we cannot achieve a better score.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,4,4,2,4], k = 0
<strong>Output:</strong> 3
<strong>Explanation:</strong> We cannot apply any operations so our score will be the frequency of the most frequent element in the original array, which is 3.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= nums.length &lt;= 10<sup>5</sup></code></li>
	<li><code>1 &lt;= nums[i] &lt;= 10<sup>9</sup></code></li>
	<li><code>0 &lt;= k &lt;= 10<sup>14</sup></code></li>
</ul>

class Solution:
    def maxFrequencyScore(self, nums: List[int], k: int) -> int:
        '''
        * score is the max count of some element in nums 
        * In one operation, increase or decrease any element by 1
        * I can only do the operation at most k times..

        * return the max score that's acheivable
        ==========
        * It's like flattening a hill, by adding or removing... the longer the flat, the larger the score..
        * Choose any index i from the array and increase or decrease nums[i] by 1.. so order of operation doesnt matter as long as it's max score..
        '''
        nums.sort()

        def check(guess): 
            pre = list(itertools.accumulate(nums, initial=0))
            ### starts with guess length..  
            for i in range(len(nums) - guess + 1): # inclusive.
                ### what will be the min operation I need to flatten this guess length by using operations + 1 and - 1
                window_middle_idx = i + (guess)//2 
                window_next_middle_idx = i + (guess + 1)//2 
                
                ### since I can do both increase and decrease.. optimal min move is by reaching the middle sum.. 
                ops_needed = (pre[i + guess] - pre[window_next_middle_idx]) - (pre[window_middle_idx] - pre[i])

                # print(nums[i: i+window_middle_idx+1], nums[window_middle_idx])
                # expected_sum = guess * nums[window_middle_idx]
                # actual_sum = pre[i+guess] - pre[i]
                # print(expected_sum)

                # ops_needed = (expected_sum - actual_sum) // 2
                # print(ops_needed)
                if ops_needed <= k: # then there is at least one window where this is possible..
                    return True
            
            return False


        l, r = 1, len(nums) # highest score when all len(nums) elements are the same..  
        while l < r:
            guess = (l + r + 1) // 2
            if check(guess): 
                l = guess
            else: 
                r = guess - 1
        return l


992