Design a music player with favorites cap

Q: Design a music player with favorites cap

This question evaluates a candidate's ability to design and implement in-memory data structures, stateful APIs, concurrency handling, deterministic policy enforcement for a fixed-capacity favorites feature, and reasoning about edge cases like removing the currently playing track or handling invalid IDs.

Q: 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.

Q: What difficulty level is this coding question?

This is a Medium difficulty Coding & Algorithms question, commonly asked during Onsite rounds at Rippling.

Q: What role is this question designed for?

This question is commonly asked for Software Engineer candidates at Rippling during technical interviews.

Question

Implement an in-memory music player that supports: addSong(id, metadata), removeSong(id), play(id), pause(), next(), prev(), getNowPlaying(), queueSong(id); and a favorites feature with fixed capacity 3 via addFavorite(id), removeFavorite(id), listFavorites(). Do not use an LRU cache; when attempting to add a fourth favorite, define deterministic behavior (e.g., reject with error). Handle corner cases: removing the currently playing song, duplicate adds, empty queue navigation, invalid song IDs, and concurrent calls. Describe chosen data structures, time/space complexities, and provide unit tests.

PracHub · Accepted Answer

def solution(operations):
    from collections import deque
    import threading

songs = {}
    queue = deque()
    prev_stack = []
    next_stack = []
    favorites = []
    favorite_set = set()
    current = None
    paused = False
    results = []
    lock = threading.Lock()

def clean_stack(stack):
        while stack and stack[-1] not in songs:
            stack.pop()

def clean_queue():
        while queue and queue[0] not in songs:
            queue.popleft()

for op in operations:
        if not isinstance(op, (list, tuple)) or not op:
            results.append('ERROR: InvalidOperation')
            continue

cmd = op[0]

with lock:
            if cmd == 'addSong':
                if len(op) != 3:
                    results.append('ERROR: InvalidOperation')
                    continue
                song_id, metadata = op[1], op[2]
                if song_id in songs:
                    results.append('ERROR: DuplicateSong')
                else:
                    songs[song_id] = metadata
                    results.append('OK')

elif cmd == 'removeSong':
                if len(op) != 2:
                    results.append('ERROR: InvalidOperation')
                    continue
                song_id = op[1]
                if song_id not in songs:
                    results.append('ERROR: SongNotFound')
                else:
                    del songs[song_id]
                    if current == song_id:
                        current = None
                        paused = False
                    if song_id in favorite_set:
                        favorite_set.remove(song_id)
                        favorites.remove(song_id)
                    results.append('OK')

elif cmd == 'play':
                if len(op) != 2:
                    results.append('ERROR: InvalidOperation')
                    continue
                song_id = op[1]
                if song_id not in songs:
                    results.append('ERROR: SongNotFound')
                else:
                    if current is not None and current != song_id:
                        prev_stack.append(current)
                    current = song_id
                    paused = False
                    next_stack.clear()
                    results.append('OK')

elif cmd == 'pause':
                if len(op) != 1:
                    results.append('ERROR: InvalidOperation')
                    continue
                if current is None:
                    results.append('ERROR: NothingPlaying')
                else:
                    paused = True
                    results.append('OK')

elif cmd == 'next':
                if len(op) != 1:
                    results.append('ERROR: InvalidOperation')
                    continue

clean_stack(next_stack)
                if next_stack:
                    next_song = next_stack.pop()
                else:
                    clean_queue()
                    if not queue:
                        results.append('ERROR: NoNextSong')
                        continue
                    next_song = queue.popleft()

if current is not None:
                    prev_stack.append(current)
                current = next_song
                paused = False
                results.append('OK')

elif cmd == 'prev':
                if len(op) != 1:
                    results.append('ERROR: InvalidOperation')
                    continue

clean_stack(prev_stack)
                if not prev_stack:
                    results.append('ERROR: NoPreviousSong')
                    continue

if current is not None:
                    next_stack.append(current)
                current = prev_stack.pop()
                paused = False
                results.append('OK')

elif cmd == 'getNowPlaying':
                if len(op) != 1:

Quick Overview

Constraints

Examples

Solution

Hints