US Nvidia MLE OA latest questions | 26NG successfully passed sharing

Nvidia MLE OA is still conducted on the Karat platform this year, with 3 questions in 90 minutes. The time is very tight, but the question types are relatively fixed (image processing + ML basic implementation). I first did the image questions that I was best at, and I completed the next two questions relatively smoothly. Below, I will fully share with you the platform information, 3 latest real questions, detailed problem-solving ideas and Python reference code.

Nvidia OA overall situation

Platform：Karat
Duration:90 minutes
Question volume: 3 questions (1 Python programming + 1 machine learning modeling + 1 AI collaboration question)
Difficulty: Mainly Medium, time is very tight
Suggestion: Do the questions you are best at first, and don’t get stuck on one question. The results will be available 1-2 weeks after submission. After passing, you will enter the technical aspect.

Nvidia MLE OA focuses on image processing + ML basic implementation, and has higher requirements for code capabilities and numerical stability.

Topic 1: Image center crop (Center Crop)

Question description

Implement a function to perform center cropping on a grayscale image represented by a two-dimensional list of integers.

Input: image (two-dimensional list of shape [H, W]), crop_height, crop_width
Output: Cropped image with shape [crop_height, crop_width]
Guarantee: the height difference between crop_height and image is an even number, the difference between crop_width and image width is an even number, and the crop size does not exceed the original image size.

Problem-solving ideas

Calculate how many pixels need to be cropped top, bottom, left and right:
- Amount of upper and lower cropping: (original image height – cropping height) // 2
- Left and right cropping amount: (original image width – cropping width) // 2
Just take out the pixels in the center area by rows and columns.

Reference code(Python):

Def solution(image: list[list[int]], crop_height: int, crop_width: int) -> list[list[int]]:

h = len(image)

w = len(image[0]) if h > 0 else 0

Start_row = (h – crop_height) // 2

End_row = start_row + crop_height

Start_col = (w – crop_width) // 2

End_col = start_col + crop_width

cropped = []

For row in image[start_row:end_row]:

         cropped.append(row[start_col:end_col])

Return cropped

Question 2: Rotate the image 90 degrees clockwise

Question description

Implement a function that rotates a grayscale image represented by a two-dimensional list of integers 90 degrees clockwise.

Input: image (a two-dimensional list of shape [H, W])
Output: rotated image with shape [W, H]
Limitation: np.rot90() cannot be used, either pure Python or numpy will work.

Problem-solving ideas(Pure Python implementation)

The essence of a 90 degree clockwise rotation is:

First transpose the original matrix (exchange rows and columns)
Then reverse each transposed row (flip left and right)

Reference code:

Def solution(image: list[list[int]]) -> list[list[int]]:

If not image or not image[0]:

return []

h = len(image)

w = len(image[0])

rotated = []

For col in range(w):

new_row = [image[h – 1 – row][col] for row in range(h)]

         rotated.append(new_row)

Return rotated

Topic 3: Softmax function implementation

Question description

Implement the Softmax function, the input is a logits list, and the output is a normalized probability list.

Formula: σ(z)i = e^zi / Σ e^zj
Restrictions: torch or numpy cannot be used; implementing it directly according to the formula may cause numerical overflow problems and requires optimization.

Problem-solving ideas(Numerically stable version)

To avoid numerical overflow caused by exponential operations, the optimization method of subtracting the maximum value is used:

σ(z)i = e^(zi – max(z)) / Σ e^(zj – max(z))

Reference code:

Import math

def solution(z: list[float]) -> list[float]:

If not z:

return []

max_z = max(z)

exps = [math.exp(x – max_z) for x in z]

sum_exps = sum(exps)

Softmax = [exp / sum_exps for exp in exps]

Return softmax

Suggestions for preparation (exclusive for 26NG MLE)

Time management: 90 minutes. The 3 questions are very intense. It is recommended to do the questions you are best at first (I did the image processing questions first).
Image processing: Nvidia MLE OA often tests basic operations such as center cropping, rotation, and normalization, and becomes familiar with two-dimensional list operations in advance.
Numerically stable: Basic ML functions such as Softmax must master the optimization skills of minimizing max.
AI collaboration problem: It may involve prompt engineering or simple multi-Agent collaboration, and learn about common collaboration modes in advance.

US Nvidia MLE OA latest questions | 26NG successfully passed sharing | Interview assistance

Nvidia OA overall situation

Topic 1: Image center crop (Center Crop)

Question 2: Rotate the image 90 degrees clockwise

Topic 3: Softmax function implementation

Suggestions for preparation (exclusive for 26NG MLE)

Recommended reading

Contact me