Meta Online Assessment Four Questions Full Explanation and Passing Ideas (30 minutes full AC)

This time Meta 's OA is a remote format with four questions and a clean and smooth platform interface.
Throughout the process, the style of the questions is biased towards basic logic and data structures, there are no off-topic questions and no nasty corner cases.
I did the whole thing in 30 minutes (45 minute cap) and each question was very regular.
The overall difficulty is approximately equivalent to LeetCode Medium on the lower end of the difficulty scale.

Many students get nervous when they hear about Meta OA, but it's really not necessary.
Meta's focus is not on algorithmic skills, but on clear logic + stable code + no errors.
Below I will go into detail about the four questions, the ideas, the points to watch out for, and a final summary of the overall strategy.

Problem 1: Maximum Difference Tracker

Problem description.
Given an array of integers, find the maximum difference between any element and the minimum element before it.
Formally, for every index I, compute arr[i] - min(arr[0.... .i-1]), and return the largest value.

Approach.

1. Initialize min_val = arr[0], max_diff = 0.
2. Traverse the array from index 1.
   • Update max_diff = max(max_diff, arr[i] - min_val)
   • Update min_val = min(min_val, arr[i])
3. Return max_diff.

Complexity.

• Time: O(n)
• Space: O(1)

Key points.
This is a warm-up question, no pitfalls. The point is variable maintenance within the loop.
But there are two little pitfalls to watch out for:

• If the array is fully decremented, the result is returned as 0 (no negative numbers can be returned).
• Some students forget to initialize min_val, resulting in an index error.

This question is mainly about the accuracy of the code and the writing style, typical of the "give points".

Problem 2: Count Strictly Greater and Decide Position

Problem description.
Given an array, for each element count how many elements are strictly greater than it.
Then, based on the counts, determine where to place the element.

• If more greater elements are on the left → place to the left
• If more are on the right → place to the right
• If equal → place to the middle

Approach.

1. Iterate through the array.
2. For each I, compare counts of greater elements before and after I.
3. If left > right → left, if right > left → right, else → middle.
4. Output final arrangement.

Complexity.

• Time: O(n²) for brute force, but given small constraints, it passes.
• Can be optimized with prefix sums or binary search on sorted order (O(n log n)).

Key points.
This question may seem simple, but it is actually a typical logical judgment question.
What a lot of people misspell is this:

• "Strictly greater than" vs "greater than or equal to" judgment is written backwards;
• Forget about dealing with equal boundary cases;
• The output format is in the wrong order.

I recommend writing this question by print debugging a few small samples before handing it in to avoid mistakes.

Problem 3: Circular Task Distribution

Problem description.
You're given N centers arranged in a circle.
Each has a capacity limit.
A sequence of tasks arrives, and for each task you need to assign it to the next available center (circularly).
If a center is closed or full, skip it.
If all centers are full, return to start and continue.

Approach.

• Maintain a pointer idx indicating current center.
• For each task.
  • Check if current center is open and has capacity.
  • If yes, assign task, reduce capacity.
  • If not, move idx = (idx + 1) % N.
  • Stop if a full circle completed without success.
• Use a closed[] array to mark unavailable centers.

Complexity.

• Time: O(N * M) worst case
• Space: O(N)

Key points.
This question is about "cyclic simulation ability".
Especially in the big factory OA, questions like this ring task assignment, rotating matrix, circular queue are especially common.
The most likely points of error are:

• forget about the pointer loop % Nwhich causes an IndexError;
• Determine if the "complete lap" condition is written incorrectly (this can be solved by using a counter or a start marker);
• Closed The status was not updated in a timely manner and the logic was misplaced.

You can run a few rounds of samples manually to see if the pointer changes as expected.

Problem 4: Largest Connected Component (Union-Find)

Problem description.
Given a binary matrix, find the size of the largest connected component of 1s.
Connectivity is defined by adjacency (left/right).

Approach.

• Treat every 1 cell as a node.
• If left/right neighbor also 1 → union the two nodes.
• Maintain parent[] And size[] arrays.
• When performing union, update size of root. size[root] += size[other_root].
• Track the largest size[root] as the answer.
• Implement path compression to optimize find operation.

Complexity.

• Time: O(N * α(N)) ≈ O(N)
• Space: O(N)

Key points.
This question is common in Meta / Amazon / Google OA.
The focus is on the correctness of the Union-Find implementation.
The error is centered on:

• Forget to initialize each node as its own father;
• The order was reversed during the union, resulting in the size not being updated;
• path compression write leaks and performance blows up.

It is recommended to memorize and check the set templates in advance to write more consistently on the spot.

Time Allocation and Strategy Recommendations

This OA was 45 minutes long in total, and my time allocation was roughly:

The remaining few minutes I spent manually verifying the samples + checking for gaps.
Meta's testing system is quite strict, if the output has one more space, or the format is wrong, it will fail.
It is recommended that you always run a few samples on your own before submitting, especially the last two questions.

Overall feeling and focus of the visit

The biggest feeling of this Meta OA:
It's not about spelling algorithms, it's about stability and proficiency.

Examining the dimensions is probably:

1. Are the algorithmic fundamentals solid(prefixed maxima, parallel check sets, simulations, etc.);
2. Careful boundary treatment.;
3. Is the time allocation reasonable.;
4. Efficient debugging capabilities.

If you normally LeetCode brushed to 300+, this set of questions is almost full seconds.
But if you don't brush up on it normally, the third question will get you stuck on circular logic, and the fourth question will be and check for set card logic bugs.

The secret to getting a Meta Offer:Programhelp Help Service

Many students roll over in the details when they do their first big factory OA:
The logic is written correctly, but a ">" is written as ">=";
Or the loop condition is misspelled, causing the sample to pass the hidden test and hang.

The Programhelp team brings together hundreds of former Amazon / Meta / Google engineers.
Long-term accompaniment of trainees practical OA + VO, provided:

Real-time voice assists (immediate alerts for choke points)

Traceless Remote Chaperone (supports all test platforms)

Debug runs with it to ensure that all hidden tests are AC'd at once.

Many of the students we assisted went from failing the first time to successfully taking the Meta / Google / TikTok Offer.
If you also want to stabilize your next OA, you're welcome to learn about the

jor jor

See Full Bio