Problem Description

This problem asks you to filter and sort data from a DataFrame containing information about animals.

Given a DataFrame animals with columns:

• name (object): the animal's name
• species (object): the animal's species
• age (int): the animal's age
• weight (int): the animal's weight in kilograms

You need to:

1. Find all animals that weigh strictly more than 100 kilograms
2. Sort these animals by their weight in descending order (heaviest first)
3. Return only the name column of these filtered and sorted animals

For example, if the input DataFrame contains 6 animals with weights of 464, 41, 328, 463, 50, and 349 kilograms, only the animals weighing more than 100 kg should be selected (464, 328, 463, 349). These should then be sorted from heaviest to lightest (464, 463, 349, 328) and only their names returned in that order.

The challenge also mentions completing this task using method chaining in a single line of code. Method chaining in pandas allows you to apply multiple operations sequentially by calling methods one after another on the same DataFrame, like .filter().sort().select().

The solution demonstrates this by:

• Using boolean indexing animals[animals['weight'] > 100] to filter rows
• Chaining .sort_values('weight', ascending=False) to sort by weight descending
• Selecting only the name column with [['name']] at the end

Intuition

The problem requires three operations on our data: filtering, sorting, and selecting specific columns. Let's think about how to approach each step.

First, we need to identify animals heavier than 100 kg. In pandas, when we want to filter rows based on a condition, we use boolean indexing. The expression animals['weight'] > 100 creates a boolean mask - a series of True/False values for each row. When we use this mask with animals[mask], pandas keeps only the rows where the mask is True.

Next, we need to sort the filtered results by weight in descending order. The .sort_values() method is the natural choice for sorting a DataFrame. By specifying ascending=False, we ensure the heaviest animals appear first.

Finally, we only want to return the names, not all columns. In pandas, we can select specific columns by passing a list of column names using bracket notation [['name']].

The beauty of pandas is that these operations can be chained together. Instead of creating intermediate variables like:

heavy_animals = animals[animals['weight'] > 100]
sorted_animals = heavy_animals.sort_values('weight', ascending=False)
result = sorted_animals[['name']]

We can combine them into a single expression:

animals[animals['weight'] > 100].sort_values('weight', ascending=False)[['name']]

This method chaining approach reads naturally from left to right: "Take animals, filter those over 100 kg, sort them by weight descending, and select just the name column." Each operation transforms the DataFrame and passes it to the next operation, creating a clean, readable pipeline of data transformations.

Solution Approach

Let's walk through the implementation step by step to understand how each part of the solution works.

Step 1: Filter animals by weight

animals[animals['weight'] > 100]

This uses boolean indexing to filter the DataFrame. The expression animals['weight'] > 100 creates a boolean Series where each element indicates whether that row's weight exceeds 100. When we pass this boolean Series back to the DataFrame using bracket notation, pandas returns only the rows where the condition is True.

For the example data:

• Tatiana (464 kg) → True
• Khaled (41 kg) → False
• Alex (328 kg) → True
• Jonathan (463 kg) → True
• Stefan (50 kg) → False
• Tommy (349 kg) → True

Step 2: Sort by weight in descending order

.sort_values('weight', ascending=False)

The .sort_values() method sorts the filtered DataFrame. We specify:

• 'weight' as the column to sort by
• ascending=False to get descending order (largest to smallest)

After sorting, the rows are reordered:

1. Tatiana (464 kg)
2. Jonathan (463 kg)
3. Tommy (349 kg)
4. Alex (328 kg)

Step 3: Select only the name column

[['name']]

Using double brackets [['name']] selects only the 'name' column and returns it as a DataFrame (not a Series). This is important because the function signature expects a DataFrame to be returned.

Complete Solution:

def findHeavyAnimals(animals: pd.DataFrame) -> pd.DataFrame:
    return animals[animals['weight'] > 100].sort_values('weight', ascending=False)[['name']]

The entire operation is performed in a single line using method chaining, where each operation's output becomes the input for the next operation. This creates an efficient pipeline that transforms the data from the original DataFrame to the final result containing only the names of heavy animals sorted by weight.

Example Walkthrough

Let's walk through a small example to illustrate the solution approach.

Suppose we have the following DataFrame with 4 animals:

Step 1: Filter animals weighing more than 100 kg

We apply the condition animals['weight'] > 100:

• Bella (85 kg) → False ❌
• Max (250 kg) → True ✓
• Charlie (45 kg) → False ❌
• Luna (180 kg) → True ✓

After filtering, we have:

Step 2: Sort by weight in descending order

We sort the filtered DataFrame by weight with ascending=False:

• Max (250 kg) comes first
• Luna (180 kg) comes second

The sorted DataFrame:

Step 3: Select only the name column

Using [['name']], we extract just the name column:

Final Result: The function returns a DataFrame containing only the names ["Max", "Luna"] in that order, representing the animals heavier than 100 kg sorted from heaviest to lightest.

The complete operation chain:

animals[animals['weight'] > 100].sort_values('weight', ascending=False)[['name']]

This elegantly transforms our initial 4-animal DataFrame into the final 2-row result containing only the names we need.

Solution Implementation

Time and Space Complexity

Time Complexity: O(n log n) where n is the number of rows in the DataFrame.

• Filtering operation animals['weight'] > 100: O(n) - iterates through all rows to check the condition
• Sorting operation sort_values('weight', ascending=False): O(n log n) - uses an efficient sorting algorithm (typically Timsort in pandas)
• Column selection [['name']]: O(m) where m is the number of filtered rows, which is at most n
• Overall complexity is dominated by the sorting step: O(n log n)

Space Complexity: O(n) where n is the number of rows in the DataFrame.

• The filtering operation creates a boolean mask: O(n)
• The filtered DataFrame is a new object containing at most n rows: O(n)
• The sorted DataFrame is another new object with the same filtered rows: O(m) where m ≤ n
• The final DataFrame with only the 'name' column: O(m) where m ≤ n
• Total auxiliary space used is O(n) in the worst case when all animals have weight > 100

Common Pitfalls

1. Using Single Brackets Instead of Double Brackets for Column Selection

A frequent mistake is using single brackets ['name'] instead of double brackets [['name']] when selecting the final column:

# Incorrect - returns a Series
return animals[animals['weight'] > 100].sort_values('weight', ascending=False)['name']

# Correct - returns a DataFrame
return animals[animals['weight'] > 100].sort_values('weight', ascending=False)[['name']]

The problem explicitly requires returning a DataFrame, but single brackets return a pandas Series. This will cause type mismatch errors since the function signature expects pd.DataFrame as the return type.

2. Using Greater Than or Equal (>=) Instead of Strictly Greater Than (>)

The problem asks for animals that weigh strictly more than 100 kg, not including 100 kg:

# Incorrect - includes animals weighing exactly 100 kg
return animals[animals['weight'] >= 100].sort_values('weight', ascending=False)[['name']]

# Correct - only animals weighing more than 100 kg
return animals[animals['weight'] > 100].sort_values('weight', ascending=False)[['name']]

This subtle difference could include or exclude animals weighing exactly 100 kg, leading to incorrect results.

3. Forgetting to Set ascending=False for Descending Order

By default, sort_values() sorts in ascending order. Forgetting to specify ascending=False will sort from lightest to heaviest:

# Incorrect - sorts in ascending order (lightest to heaviest)
return animals[animals['weight'] > 100].sort_values('weight')[['name']]

# Correct - sorts in descending order (heaviest to lightest)
return animals[animals['weight'] > 100].sort_values('weight', ascending=False)[['name']]

4. Modifying the Original DataFrame

When not using method chaining, some might accidentally modify the original DataFrame with inplace=True:

# Incorrect - modifies the original DataFrame
heavy_animals = animals[animals['weight'] > 100]
heavy_animals.sort_values('weight', ascending=False, inplace=True)
return heavy_animals[['name']]

# Correct - creates a new sorted DataFrame
heavy_animals = animals[animals['weight'] > 100]
sorted_heavy_animals = heavy_animals.sort_values('weight', ascending=False)
return sorted_heavy_animals[['name']]

Using inplace=True can cause side effects and unexpected behavior, especially if the original DataFrame is used elsewhere.

5. Handling Empty Results

If no animals weigh more than 100 kg, the solution should return an empty DataFrame with the correct structure:

def findHeavyAnimals(animals: pd.DataFrame) -> pd.DataFrame:
    result = animals[animals['weight'] > 100].sort_values('weight', ascending=False)[['name']]
    # The above naturally handles empty results correctly
    return result

The current solution handles this case properly, but developers might be tempted to add unnecessary error checking that could actually break the expected behavior of returning an empty DataFrame with the 'name' column.