Drop Missing Data - Practice Coding Problems

Drop Missing Data - Problem

Database Easy

Data Cleaning Challenge: Remove Incomplete Records

You are working as a data analyst for a university and have received a students DataFrame with incomplete information. Some student records are missing their name values, which makes them unusable for analysis.

Your task is to clean the dataset by removing all rows where the name column contains missing values (NaN, None, or null).

DataFrame Schema:

Column Name	Type	Description
student_id	int	Unique identifier for each student
name	object	Student's full name (may contain missing values)
age	int	Student's age in years

Goal: Return a clean DataFrame containing only the rows with complete name information.

Input & Output

example_1.py — Basic Missing Values

$ Input: students = pd.DataFrame({ 'student_id': [1, 2, 3], 'name': ['Alice', None, 'Bob'], 'age': [20, 21, 19] })

› Output: student_id name age 0 1 Alice 20 1 3 Bob 19

💡 Note: Row with student_id=2 is removed because the name column contains None (missing value). The remaining rows with valid names are kept and the index is reset.

example_2.py — Multiple Missing Types

$ Input: students = pd.DataFrame({ 'student_id': [1, 2, 3, 4, 5], 'name': ['Alice', np.nan, 'Bob', None, 'Charlie'], 'age': [20, 21, 19, 22, 23] })

› Output: student_id name age 0 1 Alice 20 1 3 Bob 19 2 5 Charlie 23

💡 Note: Rows with student_id=2 (np.nan) and student_id=4 (None) are removed as both represent missing values. Only rows with actual string names are retained.

example_3.py — Edge Case: All Valid

$ Input: students = pd.DataFrame({ 'student_id': [1, 2, 3], 'name': ['Alice', 'Bob', 'Charlie'], 'age': [20, 21, 22] })

› Output: student_id name age 0 1 Alice 20 1 2 Bob 21 2 3 Charlie 22

💡 Note: No rows are removed because all students have valid names. The DataFrame remains unchanged except for potentially resetting the index.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the data using optimized vectorized operations

✓ Linear Growth

Space Complexity

O(n)

Creates a new DataFrame with the filtered rows, but uses optimized memory management

⚡ Linearithmic Space

Constraints

1 ≤ number of rows ≤ 10⁶
student_id values are unique integers
age values are positive integers between 1 and 150
Missing values in name column can be None, NaN, or null
Valid names are non-null strings (empty strings are considered valid in pandas)

Asked in

The optimal solution uses pandas' built-in dropna(subset=['name']) method, which leverages vectorized operations to efficiently remove rows with missing values in O(n) time. This approach is significantly faster than manual iteration and handles all types of missing values (None, NaN, null) automatically.

Common Approaches

Approach	Time	Space	Notes
✓ Row-by-Row Iteration (Brute Force)	O(n)	O(n)	Iterate through each row and manually check for missing names
Pandas Built-in Methods (Optimal)	O(n)	O(n)	Use pandas' optimized dropna() method for efficient missing value removal

Row-by-Row Iteration (Brute Force) — Algorithm Steps

Create an empty list to store valid rows
Iterate through each row in the DataFrame
Check if the name column is not null/NaN
If valid, add the row to our list
Convert the list back to a DataFrame

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with Original DataFrame

Begin with the complete dataset containing both valid and invalid rows

Check Each Row

Iterate through each row and examine the name column for missing values

Filter Valid Rows

Keep only rows where the name column has a valid (non-null) value

Build Result

Construct the final cleaned DataFrame with only complete records

Code -

solution.c — C

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

typedef struct {
    int student_id;
    char* name;  // NULL represents missing value
    int age;
} StudentRecord;

typedef struct {
    StudentRecord* records;
    int count;
    int capacity;
} StudentArray;

StudentArray* dropnaBruteForce(StudentRecord* students, int count) {
    StudentArray* result = malloc(sizeof(StudentArray));
    result->capacity = count;
    result->records = malloc(sizeof(StudentRecord) * count);
    result->count = 0;
    
    // Iterate through each student record
    for (int i = 0; i < count; i++) {
        // Check if name is not NULL and not empty
        if (students[i].name != NULL && strlen(students[i].name) > 0) {
            // Copy the valid record
            result->records[result->count].student_id = students[i].student_id;
            result->records[result->count].name = malloc(strlen(students[i].name) + 1);
            strcpy(result->records[result->count].name, students[i].name);
            result->records[result->count].age = students[i].age;
            result->count++;
        }
    }
    
    return result;
}

void freeStudentArray(StudentArray* arr) {
    for (int i = 0; i < arr->count; i++) {
        free(arr->records[i].name);
    }
    free(arr->records);
    free(arr);
}

int main() {
    StudentRecord students[] = {
        {1, "Alice", 20},
        {2, NULL, 21},        // NULL represents missing
        {3, "Bob", 19},
        {4, "Charlie", 22},
        {5, "", 20}           // Empty string
    };
    
    int count = sizeof(students) / sizeof(StudentRecord);
    StudentArray* result = dropnaBruteForce(students, count);
    
    printf("Valid student records:\n");
    for (int i = 0; i < result->count; i++) {
        printf("ID: %d, Name: %s, Age: %d\n", 
               result->records[i].student_id,
               result->records[i].name,
               result->records[i].age);
    }
    
    freeStudentArray(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Must examine each row once, where n is the number of rows

✓ Linear Growth

Space Complexity

O(n)

Creates a new DataFrame with filtered rows, potentially storing up to n rows

⚡ Linearithmic Space

Constraints

1 ≤ number of rows ≤ 10⁶
student_id values are unique integers
age values are positive integers between 1 and 150
Missing values in name column can be None, NaN, or null
Valid names are non-null strings (empty strings are considered valid in pandas)

25.0K Views

Medium Frequency

~15 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Row-by-Row Iteration (Brute Force) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler