Get the Size of a DataFrame

Get the Size of a DataFrame - Problem

Pandas Easy

Given a DataFrame called players with the following schema:

Column Name	Type
player_id	int
name	object
age	int
position	object
...	...

Write a solution to calculate and display the number of rows and columns of the DataFrame.

Return the result as an array: [number of rows, number of columns]

Input & Output

Example 1 — Basic DataFrame

$ Input: players = [{"player_id": 1, "name": "Alice", "age": 25, "position": "Forward"}, {"player_id": 2, "name": "Bob", "age": 30, "position": "Guard"}, {"player_id": 3, "name": "Charlie", "age": 28, "position": "Center"}]

› Output: [3, 4]

💡 Note: The DataFrame has 3 rows (players) and 4 columns (player_id, name, age, position), so we return [3, 4]

Example 2 — Single Row

$ Input: players = [{"player_id": 1, "name": "Alice", "age": 25, "position": "Forward"}]

› Output: [1, 4]

💡 Note: Only one player with 4 attributes, so dimensions are [1, 4]

Example 3 — Empty DataFrame

$ Input: players = []

› Output: [0, 0]

💡 Note: Empty DataFrame has no rows and no columns, returning [0, 0]

Constraints

DataFrame can have 0 or more rows
DataFrame can have 0 or more columns
All rows must have the same number of columns
Column names are strings
Cell values can be any data type

Visualization

Tap to expand

Asked in

M Meta 15 N Netflix 12 S Spotify 8

The key insight is to use DataFrame's built-in shape property which returns dimensions as a tuple. Best approach uses players.shape to get (rows, columns) instantly. Time: O(1), Space: O(1)

Common Approaches

✓ Hash Map

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

Built-in Shape Property

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

Pandas DataFrame has a built-in shape property that returns a tuple (rows, columns) containing the dimensions. This is the most efficient and pythonic way to get DataFrame size.

Manual Counting

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

Loop through each row to count total rows, then examine the columns to count total columns. This approach manually counts dimensions without using built-in methods.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_PATTERNS 10000
#define MAX_WORDS_PER_PATTERN 100

typedef struct {
    char patterns[MAX_PATTERNS][101];
    static char words[MAX_PATTERNS][MAX_WORDS_PER_PATTERN][101];
    int wordCounts[MAX_PATTERNS];
    int patternCount;
} MagicDictionary;

MagicDictionary* magicDictionaryCreate() {
    MagicDictionary* obj = (MagicDictionary*)malloc(sizeof(MagicDictionary));
    obj->patternCount = 0;
    for (int i = 0; i < MAX_PATTERNS; i++) {
        obj->wordCounts[i] = 0;
    }
    return obj;
}

int findPattern(MagicDictionary* obj, char* pattern) {
    for (int i = 0; i < obj->patternCount; i++) {
        if (strcmp(obj->patterns[i], pattern) == 0) {
            return i;
        }
    }
    return -1;
}

void magicDictionaryBuildDict(MagicDictionary* obj, char** dictionary, int dictionarySize) {
    obj->patternCount = 0;
    for (int i = 0; i < MAX_PATTERNS; i++) {
        obj->wordCounts[i] = 0;
    }
    
    for (int i = 0; i < dictionarySize; i++) {
        char* word = dictionary[i];
        int len = strlen(word);
        for (int j = 0; j < len; j++) {
            char pattern[101];
            strcpy(pattern, word);
            pattern[j] = '*';
            
            int idx = findPattern(obj, pattern);
            if (idx == -1) {
                strcpy(obj->patterns[obj->patternCount], pattern);
                obj->wordCounts[obj->patternCount] = 0;
                idx = obj->patternCount++;
            }
            strcpy(obj->words[idx][obj->wordCounts[idx]], word);
            obj->wordCounts[idx]++;
        }
    }
}

bool magicDictionarySearch(MagicDictionary* obj, char* searchWord) {
    int len = strlen(searchWord);
    for (int i = 0; i < len; i++) {
        char pattern[101];
        strcpy(pattern, searchWord);
        pattern[i] = '*';
        
        int idx = findPattern(obj, pattern);
        if (idx != -1) {
            for (int j = 0; j < obj->wordCounts[idx]; j++) {
                if (strcmp(obj->words[idx][j], searchWord) != 0) {
                    return true;
                }
            }
        }
    }
    return false;
}

char* parseString(char* input, int* pos) {
    while (input[*pos] == ' ' || input[*pos] == ',') (*pos)++;
    if (input[*pos] == '"') (*pos)++;
    
    int start = *pos;
    while (input[*pos] != '"' && input[*pos] != ',' && input[*pos] != ']' && input[*pos] != '\0') (*pos)++;
    
    static char result[101];
    int len = *pos - start;
    strncpy(result, input + start, len);
    result[len] = '\0';
    
    if (input[*pos] == '"') (*pos)++;
    return result;
}

int parseStringArray(char* input, char results[][101]) {
    int count = 0;
    int pos = 0;
    
    while (input[pos] != '[') pos++;
    pos++;
    
    if (input[pos] == ']') return 0;
    
    while (input[pos] != ']' && input[pos] != '\0') {
        char* str = parseString(input, &pos);
        strcpy(results[count], str);
        count++;
        while (input[pos] == ',' || input[pos] == ' ') pos++;
    }
    
    return count;
}

int main() {
    char operationsLine[1000];
    char inputsLine[2000];
    
    fgets(operationsLine, sizeof(operationsLine), stdin);
    fgets(inputsLine, sizeof(inputsLine), stdin);
    
    // Remove newlines
    operationsLine[strcspn(operationsLine, "\n")] = 0;
    inputsLine[strcspn(inputsLine, "\n")] = 0;
    
    char operations[10][20];
    int opCount = parseStringArray(operationsLine, operations);
    
    MagicDictionary* magicDict = magicDictionaryCreate();
    
    printf("[");
    
    int inputPos = 0;
    while (inputsLine[inputPos] != '[') inputPos++;
    inputPos++;
    
    for (int i = 0; i < opCount; i++) {
        if (i > 0) printf(",");
        
        if (strcmp(operations[i], "MagicDictionary") == 0) {
            printf("null");
            // Skip empty array []
            while (inputsLine[inputPos] != ']') inputPos++;
            inputPos++;
        } else if (strcmp(operations[i], "buildDict") == 0) {
            char dict[100][101];
            char dictInput[1000];
            
            // Extract dictionary array
            int start = inputPos;
            int brackets = 0;
            while (inputsLine[inputPos] != '\0') {
                if (inputsLine[inputPos] == '[') brackets++;
                else if (inputsLine[inputPos] == ']') {
                    brackets--;
                    if (brackets == 0) {
                        inputPos++;
                        break;
                    }
                }
                inputPos++;
            }
            
            int len = inputPos - start;
            strncpy(dictInput, inputsLine + start, len);
            dictInput[len] = '\0';
            
            char* dictWords[100];
            int dictSize = parseStringArray(dictInput, dict);
            for (int j = 0; j < dictSize; j++) {
                dictWords[j] = dict[j];
            }
            
            magicDictionaryBuildDict(magicDict, dictWords, dictSize);
            printf("null");
        } else if (strcmp(operations[i], "search") == 0) {
            char* searchWord = parseString(inputsLine, &inputPos);
            bool result = magicDictionarySearch(magicDict, searchWord);
            printf("%s", result ? "true" : "false");
        }
        
        while (inputsLine[inputPos] == ',' || inputsLine[inputPos] == ' ') inputPos++;
    }
    
    printf("]\n");
    
    free(magicDict);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

33.0K Views

High Frequency

~5 min Avg. Time

892 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