Create a DataFrame from List

Create a DataFrame from List - Problem

Pandas Easy

Write a solution to create a DataFrame from a 2D list called student_data. This 2D list contains the IDs and ages of some students.

The DataFrame should have two columns, student_id and age, and be in the same order as the original 2D list.

Note: The function should return a pandas DataFrame object with the specified column names and data structure.

Input & Output

Example 1 — Basic Student Data

$ Input: student_data = [[1, 15], [2, 11], [3, 11], [4, 20]]

› Output: {"student_id": [1, 2, 3, 4], "age": [15, 11, 11, 20]}

💡 Note: Create DataFrame with student_id and age columns from the 2D list. Each inner list becomes a row with ID in first column and age in second column.

Example 2 — Minimum Data

$ Input: student_data = [[5, 18]]

› Output: {"student_id": [5], "age": [18]}

💡 Note: Single student data creates DataFrame with one row containing student ID 5 and age 18.

Example 3 — Multiple Students Same Age

$ Input: student_data = [[10, 22], [11, 22], [12, 19]]

› Output: {"student_id": [10, 11, 12], "age": [22, 22, 19]}

💡 Note: DataFrame maintains order and allows duplicate ages. Students 10 and 11 both have age 22.

Constraints

1 ≤ student_data.length ≤ 1000
student_data[i].length = 2
1 ≤ student_data[i][0] ≤ 10⁶ (student ID)
1 ≤ student_data[i][1] ≤ 100 (age)

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 12 a Amazon 18 M Microsoft 10

The key insight is to use pandas DataFrame constructor with the data parameter and column names. Best approach is the direct constructor method: pd.DataFrame(student_data, columns=['student_id', 'age']). Time: O(n), Space: O(n).

Common Approaches

✓ Direct DataFrame Constructor

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

Directly create the DataFrame by passing the 2D list as data and specifying column names in the constructor. This is the most efficient and pythonic approach for this task.

Manual Row-by-Row Construction

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

Initialize an empty DataFrame with column names, then loop through the 2D list and add each row one by one using loc indexing. This approach mimics manual data entry.

Direct DataFrame Constructor — Algorithm Steps

Pass student_data as data parameter
Specify columns=['student_id', 'age']
DataFrame constructor handles the conversion automatically

Visualization

Tap to expand

Step-by-Step Walkthrough

Input 2D List

Student data as nested list

Constructor Call

pd.DataFrame(data, columns=...)

Structured DataFrame

Complete DataFrame with proper columns

Code -

solution.c — C

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

typedef struct {
    int* student_id;
    int* age;
    int size;
} DataFrame;

DataFrame solution(int** studentData, int rows) {
    DataFrame df;
    df.student_id = (int*)malloc(rows * sizeof(int));
    df.age = (int*)malloc(rows * sizeof(int));
    df.size = rows;
    
    // Direct transformation of data
    for (int i = 0; i < rows; i++) {
        df.student_id[i] = studentData[i][0];
        df.age[i] = studentData[i][1];
    }
    
    return df;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for [[1,15],[2,11],...] format
    int** studentData = (int**)malloc(100 * sizeof(int*));
    int rows = 0;
    
    char* ptr = line + 1; // Skip first '['
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            studentData[rows] = (int*)malloc(2 * sizeof(int));
            ptr++; // Skip '['
            sscanf(ptr, "%d,%d", &studentData[rows][0], &studentData[rows][1]);
            rows++;
            while (*ptr != ']') ptr++; // Find closing bracket
        }
        ptr++;
    }
    
    DataFrame result = solution(studentData, rows);
    
    printf("{\"student_id\":[");
    for (int i = 0; i < result.size; i++) {
        printf("%d", result.student_id[i]);
        if (i < result.size - 1) printf(",");
    }
    printf("],\"age\":[");
    for (int i = 0; i < result.size; i++) {
        printf("%d", result.age[i]);
        if (i < result.size - 1) printf(",");
    }
    printf("]}\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

DataFrame constructor processes n rows in single operation

✓ Linear Growth

Space Complexity

O(n)

DataFrame stores n rows of student data

⚡ Linearithmic Space

23.0K Views

High Frequency

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

Direct DataFrame Constructor — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler