Method Chaining

Method Chaining - Problem

Database Easy

Given a DataFrame animals with columns name, species, age, and weight, write a solution to list the names of animals that weigh strictly more than 100 kilograms.

Return the animals sorted by weight in descending order.

Input & Output

Example 1 — Basic Filtering

$ Input: animals = [{"name":"Lion","species":"Panthera leo","age":5,"weight":80},{"name":"Elephant","species":"Loxodonta africana","age":10,"weight":150}]

› Output: ["Elephant"]

💡 Note: Only Elephant weighs more than 100kg (150 > 100), so return ["Elephant"]

Example 2 — Multiple Heavy Animals

$ Input: animals = [{"name":"Rhino","species":"Rhinoceros","age":8,"weight":120},{"name":"Hippo","species":"Hippopotamus","age":6,"weight":180},{"name":"Elephant","species":"Elephantidae","age":12,"weight":150}]

› Output: ["Hippo","Elephant","Rhino"]

💡 Note: All three animals weigh > 100kg. Sorted by weight descending: Hippo(180), Elephant(150), Rhino(120)

Example 3 — No Heavy Animals

$ Input: animals = [{"name":"Tiger","species":"Panthera tigris","age":4,"weight":90},{"name":"Lion","species":"Panthera leo","age":3,"weight":85}]

› Output: []

💡 Note: No animals weigh more than 100kg (Tiger: 90kg, Lion: 85kg), so return empty array

Constraints

1 ≤ animals.length ≤ 10⁴
1 ≤ weight ≤ 1000
name contains only letters and spaces

Visualization

Tap to expand

Asked in

M Meta 25 G Google 20 a Amazon 15

The key insight is to use DataFrame operations for efficient filtering and sorting. Filter animals with weight > 100, sort by weight descending, then select names. Best approach uses method chaining for readable code. Time: O(n log n), Space: O(k)

Common Approaches

✓ Brute Force Iteration

⏱️ Time: O(n log n) Space: O(k)

Loop through every animal record, check if weight > 100, collect matching names in a list, then sort the results by weight in descending order.

Method Chaining

⏱️ Time: O(n log n) Space: O(k)

Apply filter condition and sort operation directly on the DataFrame using built-in methods, leveraging pandas-style operations for efficient data processing.

Brute Force Iteration — Algorithm Steps

Step 1: Create empty result list
Step 2: Loop through all animals
Step 3: Check weight > 100 condition
Step 4: Sort by weight descending

Visualization

Tap to expand

Step-by-Step Walkthrough

Filter

Check each animal's weight > 100

Collect

Gather heavy animals

Sort

Sort by weight descending

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char name[100];
    char species[100];
    int age;
    int weight;
} Animal;

typedef struct {
    Animal* animals;
    int count;
} AnimalArray;

int compare_weights(const void *a, const void *b) {
    Animal *animalA = (Animal*)a;
    Animal *animalB = (Animal*)b;
    return animalB->weight - animalA->weight; // Descending order
}

char* extractStringValue(const char* json, const char* key, char* result) {
    char pattern[110];
    sprintf(pattern, "\"%s\"", key);
    
    char* pos = strstr(json, pattern);
    if (!pos) return NULL;
    
    pos = strchr(pos, ':');
    if (!pos) return NULL;
    
    pos = strchr(pos, '"');
    if (!pos) return NULL;
    pos++;
    
    char* end = strchr(pos, '"');
    if (!end) return NULL;
    
    int len = end - pos;
    strncpy(result, pos, len);
    result[len] = '\0';
    
    return result;
}

int extractIntValue(const char* json, const char* key) {
    char pattern[110];
    sprintf(pattern, "\"%s\"", key);
    
    char* pos = strstr(json, pattern);
    if (!pos) return 0;
    
    pos = strchr(pos, ':');
    if (!pos) return 0;
    pos++;
    
    while (*pos && (*pos == ' ' || *pos == '\t')) pos++;
    
    return atoi(pos);
}

AnimalArray parseAnimals(const char* json) {
    AnimalArray result = {NULL, 0};
    
    char* jsonCopy = malloc(strlen(json) + 1);
    strcpy(jsonCopy, json);
    
    // Remove outer brackets
    char* start = strchr(jsonCopy, '[');
    if (!start) {
        free(jsonCopy);
        return result;
    }
    start++;
    
    char* end = strrchr(jsonCopy, ']');
    if (end) *end = '\0';
    
    // Count objects
    int count = 0;
    char* p = start;
    int braceCount = 0;
    while (*p) {
        if (*p == '{') braceCount++;
        else if (*p == '}') {
            braceCount--;
            if (braceCount == 0) count++;
        }
        p++;
    }
    
    if (count == 0) {
        free(jsonCopy);
        return result;
    }
    
    result.animals = malloc(count * sizeof(Animal));
    result.count = 0;
    
    // Parse objects
    p = start;
    braceCount = 0;
    char* objStart = NULL;
    
    while (*p) {
        if (*p == '{') {
            if (braceCount == 0) objStart = p;
            braceCount++;
        } else if (*p == '}') {
            braceCount--;
            if (braceCount == 0 && objStart) {
                char objBuffer[1000];
                int objLen = p - objStart + 1;
                strncpy(objBuffer, objStart, objLen);
                objBuffer[objLen] = '\0';
                
                Animal* animal = &result.animals[result.count];
                extractStringValue(objBuffer, "name", animal->name);
                extractStringValue(objBuffer, "species", animal->species);
                animal->age = extractIntValue(objBuffer, "age");
                animal->weight = extractIntValue(objBuffer, "weight");
                
                result.count++;
            }
        }
        p++;
    }
    
    free(jsonCopy);
    return result;
}

char** solution(Animal* animals, int count, int* resultCount) {
    Animal* heavy_animals = malloc(count * sizeof(Animal));
    int heavy_count = 0;
    
    for (int i = 0; i < count; i++) {
        if (animals[i].weight > 100) {
            heavy_animals[heavy_count++] = animals[i];
        }
    }
    
    // Sort by weight descending
    qsort(heavy_animals, heavy_count, sizeof(Animal), compare_weights);
    
    // Extract names
    char** result = malloc(heavy_count * sizeof(char*));
    for (int i = 0; i < heavy_count; i++) {
        result[i] = malloc(strlen(heavy_animals[i].name) + 1);
        strcpy(result[i], heavy_animals[i].name);
    }
    
    *resultCount = heavy_count;
    free(heavy_animals);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    AnimalArray animals = parseAnimals(line);
    int resultCount;
    char** result = solution(animals.animals, animals.count, &resultCount);
    
    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("\"%s\"", result[i]);
        if (i < resultCount - 1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    
    free(result);
    if (animals.animals) free(animals.animals);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

One pass to filter (O(n)) plus sorting filtered results (O(k log k) where k ≤ n)

⚡ Linearithmic

Space Complexity

O(k)

Space for filtered results list containing k animals where k ≤ n

✓ Linear Space

31.5K Views

Medium Frequency

~8 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Iteration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler