Fill Missing Data

Fill Missing Data - Problem

Database Easy

You are given a DataFrame products with the following schema:

Column Name	Type
name	object
quantity	int
price	int

Write a solution to fill in the missing values as 0 in the quantity column.

Return the modified DataFrame with all missing quantity values replaced with 0.

Input & Output

Example 1 — Basic Missing Values

$ Input: products = [{'name': 'Apple', 'quantity': 10, 'price': 5}, {'name': 'Banana', 'quantity': null, 'price': 3}, {'name': 'Orange', 'quantity': 15, 'price': 4}]

› Output: [{'name': 'Apple', 'quantity': 10, 'price': 5}, {'name': 'Banana', 'quantity': 0, 'price': 3}, {'name': 'Orange', 'quantity': 15, 'price': 4}]

💡 Note: The Banana row has a missing quantity value (null), which gets replaced with 0. Other rows remain unchanged.

Example 2 — Multiple Missing Values

$ Input: products = [{'name': 'Laptop', 'quantity': null, 'price': 1000}, {'name': 'Mouse', 'quantity': 25, 'price': 20}, {'name': 'Keyboard', 'quantity': null, 'price': 50}]

› Output: [{'name': 'Laptop', 'quantity': 0, 'price': 1000}, {'name': 'Mouse', 'quantity': 25, 'price': 20}, {'name': 'Keyboard', 'quantity': 0, 'price': 50}]

💡 Note: Both Laptop and Keyboard have missing quantities, both get filled with 0. Mouse quantity remains unchanged.

Example 3 — No Missing Values

$ Input: products = [{'name': 'Phone', 'quantity': 100, 'price': 500}, {'name': 'Tablet', 'quantity': 50, 'price': 300}]

› Output: [{'name': 'Phone', 'quantity': 100, 'price': 500}, {'name': 'Tablet', 'quantity': 50, 'price': 300}]

💡 Note: No missing values in quantity column, so DataFrame remains exactly the same.

Constraints

1 ≤ products.length ≤ 1000
name is a non-empty string
quantity can be null or a non-negative integer
price is a positive integer

Visualization

Tap to expand

Asked in

N Netflix 25 S Spotify 20 U Uber 18 A Airbnb 15

The key insight is to use pandas' built-in fillna() method for efficient missing value replacement. Best approach is the optimized pandas method using products['quantity'].fillna(0). Time: O(n), Space: O(1)

Common Approaches

✓ Bfs

⏱️ Time: N/A Space: N/A

Manual Row Iteration

⏱️ Time: O(n) Space: O(1)

Loop through every row in the DataFrame, check if the quantity value is NaN (missing), and replace it with 0. This approach processes each row individually.

Pandas fillna() Method

⏱️ Time: O(n) Space: O(1)

Leverage pandas' optimized fillna() method which is specifically designed for handling missing data. This method operates on the entire column at once using vectorized operations.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct Queue {
    struct TreeNode** nodes;
    int front, rear, size, capacity;
};

struct Queue* createQueue(int capacity) {
    struct Queue* q = (struct Queue*)malloc(sizeof(struct Queue));
    q->nodes = (struct TreeNode**)malloc(capacity * sizeof(struct TreeNode*));
    q->front = q->size = 0;
    q->rear = capacity - 1;
    q->capacity = capacity;
    return q;
}

int isEmpty(struct Queue* q) { return q->size == 0; }
int isFull(struct Queue* q) { return q->size == q->capacity; }

void enqueue(struct Queue* q, struct TreeNode* node) {
    if (isFull(q)) return;
    q->rear = (q->rear + 1) % q->capacity;
    q->nodes[q->rear] = node;
    q->size++;
}

struct TreeNode* dequeue(struct Queue* q) {
    if (isEmpty(q)) return NULL;
    struct TreeNode* node = q->nodes[q->front];
    q->front = (q->front + 1) % q->capacity;
    q->size--;
    return node;
}

int solution(struct TreeNode* root) {
    if (!root) return 0;
    
    struct Queue* queue = createQueue(1000);
    enqueue(queue, root);
    int leftmostVal = root->val;
    
    while (!isEmpty(queue)) {
        int levelSize = queue->size;
        
        for (int i = 0; i < levelSize; i++) {
            struct TreeNode* node = dequeue(queue);
            
            // First node in this level is the leftmost
            if (i == 0) {
                leftmostVal = node->val;
            }
            
            if (node->left) enqueue(queue, node->left);
            if (node->right) enqueue(queue, node->right);
        }
    }
    
    free(queue->nodes);
    free(queue);
    return leftmostVal;
}

struct TreeNode* createNode(int val) {
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

struct TreeNode* buildTree(char* input) {
    if (!input || strlen(input) < 3) return NULL;
    
    // Remove brackets and split by comma
    char* str = malloc(strlen(input) + 1);
    strcpy(str, input);
    
    // Remove '[' and ']'
    if (str[0] == '[') str++;
    if (str[strlen(str)-1] == ']') str[strlen(str)-1] = '\0';
    
    if (strlen(str) == 0) return NULL;
    
    // Parse first value as root
    char* token = strtok(str, ",");
    if (!token || strcmp(token, "null") == 0) return NULL;
    
    struct TreeNode* root = createNode(atoi(token));
    struct TreeNode* queue[10000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    
    while (front < rear && (token = strtok(NULL, ","))) {
        struct TreeNode* node = queue[front++];
        
        // Left child
        if (strcmp(token, "null") != 0) {
            node->left = createNode(atoi(token));
            queue[rear++] = node->left;
        }
        
        // Right child
        if ((token = strtok(NULL, ","))) {
            if (strcmp(token, "null") != 0) {
                node->right = createNode(atoi(token));
                queue[rear++] = node->right;
            }
        }
    }
    
    return root;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Remove newline
    input[strcspn(input, "\n")] = 0;
    
    struct TreeNode* root = buildTree(input);
    int result = solution(root);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

31.2K Views

High Frequency

~5 min Avg. Time

890 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