Meta 26 SWE Intern OA Four Questions Full Review: This time it really focuses on “implementation capabilities” rather than pure algorithms

I just helped a classmate get it recently Meta 26 SWE Intern OA , all four Codesignal questions were AC. To be honest, the style of the questions this time is quite Meta: it will not give you particularly hard algorithms, but it will place great emphasis on implementation details, simulation capabilities, and boundary judgment. If you still hold the idea that "you can pass the 100 classic LeetCode questions", then you have already lost at the starting line.

Q1 — Minimum Sum After One Operation

Question overview
Given an array of positive integers Nums, you may perform the following operation at most once:
Choose an index I And replace Nums[i] With the sum of digits of Nums[i].
Return the minimum possible total sum after performing zero or one operation.

Example
Nums = [14, 7, 20]
Replace 20 → 2 → smallest sum → 29.

Ideas
This question is to help you get started:

• The original sum is calculated first
• Calculate digit sum for each number
• Make a difference between "before and after replacement"
• Just be greedy and take the minimum

It’s not too difficult, just the taste of typical Codesignal Q1.

Q2 — Delivery System Using Drones

This question has a "Meta product simulation" feel. It's not that the algorithm is difficult, but the steps are detailed.

Question overview
Given a target distance and a list of station positions, you must deliver a package to the target using drones.
A drone can fly at most 10 units Including the final hop.
You must always:

1. Take the goods from the current point to the nearest station
2. Use station’s drone to deliver goods (up to 10 units)
3. If the drone does not fly to the target → you have to walk over empty-handed to get the goods
4. Repeat until target is reached
   Return total distance With cargo.

Key points
Meta likes this kind of question very much. Just follow the steps given in the question.
What really matters is:

• Stations must be sorted first, otherwise they will overturn
• When walking, only the distance "carrying goods" is accumulated
• Don’t overthink the steps of the simulation, just follow the order of the questions and you’ll be foolproof

The overall problem is implementation, but there are a lot of details.

Q3 — Battery Usage Simulation

This question is a typical Codesignal medium-difficulty "Dynamic Resource Management" question.

Question overview
You want to run your phone for total time T.
You have multiple batteries, each with Capacity[i] (usable duration) and Recharge[i] (time required to fully recharge).
You must follow the rules:

1. Only use fully-charged batteries
2. Put the battery back to charge immediately after using it
3. If battery is required but there is no fully-charged → return -1
   Return How many batteries did you use to get enough time t? If the last one is not used, all batteries must be charging, otherwise return -1.

Core logic

• Cur Maintain current time
• K[i] It’s the next time the battery is fully charged.
• The battery that can be used must meet the requirements K[i] <= cur
• Update after use K[i] = cur + recharge[i]
• Keep iterating until Cur >= t

This question may seem greedy, but it is actually a simulation. The difficulty is the judgment of "the last piece is useless", many people get stuck here.

Q4 — Primary + Secondary Arrays with Operations

This question is the most difficult of the four, and most people get stuck here.

Question overview
You’re given two arrays:
Primary And Secondary, and a list of operations.
There are two types:

1. [0, index, val] → update secondary[index] = val
2. [1, targetSum] → return count of pairs (i,j) Such that
   Primary[i] + secondary[j] == targetSum

The primary remains unchanged, and the secondary will be updated frequently.

Why does the traversal time out?

• If you traverse primary × secondary every time, it will be O(N*M) completely exploded
• Even if the primary is made into a hashmap, and then traversing the secondary is O(N+M), each query will be too large.

The actual solution Meta gives a very obvious hint:
"an array fixed / an array dynamic"
→ This is typical Two-sum with update Structure.

The best solution: frequency table + dynamic maintenance

• Create freq for primary (fixed)
• Create freq for secondary (can be modified dynamically)
• Update when type=0: delete old values ​​and add new values ​​from freqSec
• Query when type=1:
  Enumerate the distinct keys of primary and check TargetSum - key Frequency in secondary
  → O(P) where P is the distinct number of primary (usually much smaller than n)

This question has the same idea as the Two-Sum frequency of LeetCode 1 / 560, but with the addition of dynamic update.

ProgramHelp: North American CS job searchUltimate solutionAndHigh-order service matrix

Our team is composed of former senior engineers from FAANG (Google, Meta, Amazon, etc.) and alumni from prestigious schools such as CMU and Stanford. We do not provide low-end intermediary services, but industry-leading, expert-level job search guarantees.

jor jor

See Full Bio