Imagine you are a developer on the Exxen engineering team. You are tasked with

enhancing the user experience by implementing a feature that efficiently calculates the median

age of Exxen users. This feature will be crucial for tailoring content recommendations based on

user age demographics.

Exxen, the largest video streaming platform in Turkey, offers a vast array of movies, TV

shows, documentaries, and more. As the user base expands, so does the need for improved

content recommendation systems. A significant part of this improvement is understanding the

median age of users, which helps in creating targeted content suggestions.

As part of a demographic study, Exxen is interested in the median age of its viewers. You

are responsible for implementing functionality that updates the median age efficiently whenever

a new user signs up$.$ To achieve this efficiently, you will use two heaps $($priority queues in Java$)$:

a max$-$heap to store the smaller half of the ages and a min$-$heap to store the larger half of the

ages. When a new age is added, if the age is less than or equal to the root of the max$-$heap, it is

added to the max$-$heap. Otherwise, it is added to the min$-$heap. After each insertion, you balance

the heaps.

If the max$-$heap has more than one extra element compared to the min$-$heap, you move

the root of the max$-$heap to the min$-$heap. If the min$-$heap has more elements than the max$-$heap,

you move the root of the min$-$heap to the max$-$heap. To find the median, if the heaps are of equal

size, the median is the average of the roots of both heaps. If the heaps are not of equal size, the

median is the root of the max$-$heap. This method ensures efficient insertion and median retrieval,

suitable for the dynamic and growing user base of Exxen.