Big Tech Lifetime Ban for AI Cheating & LeetCode 1224 Max Equal Frequency Solution

AI Cheating in Big Tech Interviews: Zero Tolerance

A recent Maimai (脉脉) post highlighted rampant AI cheating in campus recruitment interviews: candidates' eyes dart to the side, screens switch suspiciously, and code passes in one shot. A big-tech employee responded that their department enforces zero tolerance — cheaters not only fail but are "written into interview feedback" (写进面评), effectively a lifetime ban across the entire company, not just the current team.

Previously, suspected cheating might only cause a rejection; now, with cheating turning from isolated incidents into batch behavior, companies raise the cost: "You want to gamble? I'll make sure you have no chips for the next round." The author praises candidates who still grind LeetCode honestly: "This path looks slowest but is actually fastest. Cheaters may win once, but never forever — the bill comes due."

LeetCode 1224: Maximum Equal Frequency

Problem Statement

Given a positive integer array nums, find the longest prefix such that after deleting exactly one element from that prefix, every remaining number appears the same number of times. If deletion leaves no elements, it is considered valid (frequency 0).

Examples

Example 1: nums = [2,2,1,1,5,3,3,5] → Output: 7. Prefix [2,2,1,1,5,3,3] (length 7), delete nums[4]=5 → [2,2,1,1,3,3] where each number appears twice.

Example 2: nums = [1,1,1,2,2,2,3,3,3,4,4,4,5] → Output: 13. The whole array works; delete the single 5 and all others appear three times.

Solution: Counting + Case Analysis

Maintain two arrays while scanning left to right: cnt[x] = frequency of value x in current prefix. sum[f] = how many distinct values have frequency f. max = maximum frequency seen so far. len = current prefix length (i+1).

At each step, update cnt, sum, max, then check three valid conditions to update answer ans:

All frequencies are 1: max == 1. Any deletion works.

One value occurs once, all others occur max times: max * sum[max] + 1 == len. Delete the singleton.

One value occurs max times, all others occur max-1 times: (max-1) * (sum[max-1] + 1) + 1 == len. Delete one occurrence from the max-frequency value.

If any condition holds, the current prefix length is a candidate for the maximum.

Reference Implementations

Java

class Solution {
    static int[] cnt = new int[100010], sum = new int[100010];
    public int maxEqualFreq(int[] nums) {
        Arrays.fill(cnt, 0); Arrays.fill(sum, 0);
        int n = nums.length, max = 0, ans = 0;
        for (int i = 0; i < n; i++) {
            int t = nums[i], cur = ++cnt[t], len = i + 1;
            sum[cur]++; sum[cur - 1]--;
            max = Math.max(max, cur);
            if (max == 1) ans = len;
            if (max * sum[max] + 1 == len) ans = len;
            if ((max - 1) * (sum[max - 1] + 1) + 1 == len) ans = len;
        }
        return ans;
    }
}

C++

class Solution {
public:
    int maxEqualFreq(vector<int>& nums) {
        vector<int> cnt(100010, 0), sumv(100010, 0);
        int n = nums.size(), maxv = 0, ans = 0;
        for (int i = 0; i < n; i++) {
            int t = nums[i], cur = ++cnt[t], len = i + 1;
            sumv[cur]++; sumv[cur - 1]--;
            maxv = max(maxv, cur);
            if (maxv == 1) ans = len;
            if (maxv * sumv[maxv] + 1 == len) ans = len;
            if ((maxv - 1) * (sumv[maxv - 1] + 1) + 1 == len) ans = len;
        }
        return ans;
    }
};

Python

class Solution:
    def maxEqualFreq(self, nums: List[int]) -> int:
        cnt, sumv = [0] * 100010, [0] * 100010
        n, maxv, ans = len(nums), 0, 0
        for i, t in enumerate(nums):
            cur, lenv = cnt[nums[i]] + 1, i + 1
            cnt[t] += 1
            sumv[cur] += 1
            sumv[cur - 1] -= 1
            maxv = max(maxv, cur)
            if maxv == 1: ans = lenv
            if maxv * sumv[maxv] + 1 == lenv: ans = lenv
            if (maxv - 1) * (sumv[maxv - 1] + 1) + 1 == lenv: ans = lenv
        return ans

TypeScript

function maxEqualFreq(nums: number[]): number {
    let n = nums.length, max = 0, ans = 0;
    const cnt = new Array<number>(100010).fill(0),
          sum = new Array<number>(100010).fill(0);
    for (let i = 0; i < n; i++) {
        let t = nums[i], len = i + 1, cur = ++cnt[t];
        sum[cur]++; sum[cur - 1]--;
        max = Math.max(max, cur);
        if (max == 1) ans = len;
        if (max * sum[max] + 1 == len) ans = len;
        if ((max - 1) * (sum[max - 1] + 1) + 1 == len) ans = len;
    }
    return ans;
}

Complexity

Time: O(n) — single pass through the array.

Space: O(M) — where M = 100010 (max value constraint), for the counting arrays.