How do I practice coding and algorithm questions?

Use PracHub's coding console to write, test, and debug your solutions in Python or JavaScript. View hints, test against sample inputs, and compare with official solutions.

What difficulty level is this coding question?

This is a medium difficulty Coding & Algorithms question, commonly asked during Technical Screen rounds at Nextdoor.

What role is this question designed for?

This question is commonly asked for Machine Learning Engineer candidates at Nextdoor during technical interviews.

Build Ranked Feed With Photo Batching | Nextdoor Coding Question

Build Ranked Feed With Photo Batching

Company: Nextdoor

Role: Machine Learning Engineer

Category: Coding & Algorithms

Difficulty: medium

Interview Round: Technical Screen

You are given a list of feed objects. Each object has: - `id`: a unique string - `type`: one of `Normal`, `Video`, or `Photo` - `score`: a numeric ranking score Construct the final feed with these rules: 1. Sort all objects by `score` in descending order. If two objects have the same score, preserve their original relative order. 2. Take all `Photo` objects in this ranked order and group them into consecutive batches of 3. The final batch may contain 1 or 2 photos. 3. Each photo batch becomes a single feed item. The score of a photo batch is the score of its first photo, which is also the highest-scored photo in that batch. 4. Merge these photo batches with all `Normal` and `Video` objects, then produce the final feed in descending score order. If scores are equal, preserve the relative order from the ranked list. Example: Input ranked objects: - `N1(Normal)` - `N2(Normal)` - `P1(Photo)` - `P2(Photo)` - `V(Video)` - `P3(Photo)` - `P4(Photo)` - `N3(Normal)` Output feed: - `N1` - `N2` - `[P1, P2, P3]` - `V` - `[P4]` - `N3` Implement a function that returns the final feed.

Quick Answer: This question evaluates algorithmic reasoning and data manipulation skills, including stable sorting, grouping/batching, and merging of ranked items while preserving ordering invariants.

You are given a list of feed objects. Each object is a dictionary with keys `id`, `type`, and `score`. The `type` is one of `Normal`, `Video`, or `Photo`. Build the final feed using these rules: 1. Sort all objects by `score` in descending order. If two objects have the same score, preserve their original relative order. 2. Take only the `Photo` objects from this ranked list and group them into consecutive batches of 3. The last batch may contain 1 or 2 photos. 3. Each photo batch becomes a single feed item. Its score is the score of its first photo. 4. Merge these photo batches with all `Normal` and `Video` objects, then order the result by descending score. If scores are equal, preserve the relative order from the ranked list. Return the final feed as a list where each `Normal` or `Video` item is represented by its `id` string, and each photo batch is represented by a list of photo `id` strings. For tie-breaking after batching, use the position of the batch's first photo in the ranked list.

Constraints

0 <= len(feed_objects) <= 100000
Each object has unique `id`
Each `type` is one of `Normal`, `Video`, or `Photo`
Scores are numeric values and may be negative or duplicated

Examples

Input: ([{'id': 'N1', 'type': 'Normal', 'score': 100}, {'id': 'N2', 'type': 'Normal', 'score': 95}, {'id': 'P1', 'type': 'Photo', 'score': 90}, {'id': 'P2', 'type': 'Photo', 'score': 89}, {'id': 'V', 'type': 'Video', 'score': 88}, {'id': 'P3', 'type': 'Photo', 'score': 87}, {'id': 'P4', 'type': 'Photo', 'score': 80}, {'id': 'N3', 'type': 'Normal', 'score': 70}],)

Expected Output: ['N1', 'N2', ['P1', 'P2', 'P3'], 'V', ['P4'], 'N3']

Explanation: After ranking, photos are P1, P2, P3, P4. They become batches [P1, P2, P3] with score 90 and [P4] with score 80, then those batches are merged with non-photo items by score.

Input: ([{'id': 'P1', 'type': 'Photo', 'score': 50}, {'id': 'N1', 'type': 'Normal', 'score': 50}, {'id': 'P2', 'type': 'Photo', 'score': 50}, {'id': 'V1', 'type': 'Video', 'score': 40}, {'id': 'P3', 'type': 'Photo', 'score': 30}],)

Expected Output: [['P1', 'P2', 'P3'], 'N1', 'V1']

Explanation: The stable ranked order keeps P1 before N1 before P2 among score-50 items. The batch [P1, P2, P3] gets score 50 and inherits P1's earlier ranked position, so it appears before N1.

Input: ([{'id': 'P1', 'type': 'Photo', 'score': 10}, {'id': 'P2', 'type': 'Photo', 'score': 30}, {'id': 'P3', 'type': 'Photo', 'score': 20}, {'id': 'P4', 'type': 'Photo', 'score': 30}],)

Expected Output: [['P2', 'P4', 'P3'], ['P1']]

Explanation: After stable sorting by score descending, the photo order is P2, P4, P3, P1. Grouping by 3 gives [P2, P4, P3] and [P1].

Input: ([],)

Expected Output: []

Explanation: An empty input list produces an empty final feed.

Input: ([{'id': 'V1', 'type': 'Video', 'score': 90}, {'id': 'P1', 'type': 'Photo', 'score': 90}, {'id': 'N1', 'type': 'Normal', 'score': 85}, {'id': 'P2', 'type': 'Photo', 'score': 80}, {'id': 'P3', 'type': 'Photo', 'score': 70}, {'id': 'P4', 'type': 'Photo', 'score': 60}],)

Expected Output: ['V1', ['P1', 'P2', 'P3'], 'N1', ['P4']]

Explanation: V1 and the first photo batch both have score 90, but V1 appears earlier in the ranked list, so it stays before the batch.

Input: ([{'id': 'N1', 'type': 'Normal', 'score': -1}, {'id': 'V1', 'type': 'Video', 'score': 5}, {'id': 'N2', 'type': 'Normal', 'score': 5}],)

Expected Output: ['V1', 'N2', 'N1']

Explanation: There are no photos, so the result is just the stable score-descending order of the non-photo items.

Hints

First create one stable ranked list by sorting on score descending. Python's sort is stable, which helps with tie-breaking.
Treat each photo batch as a synthetic item whose score and position come from its first photo, then merge those synthetic items with non-photo items.

Quick Overview

This question evaluates algorithmic reasoning and data manipulation skills, including stable sorting, grouping/batching, and merging of ranked items while preserving ordering invariants.