Inversion of Object - Practice Coding Problems

Inversion of Object - Problem

Database Easy

Inversion of Object is a fundamental data transformation problem that challenges you to flip the relationship between keys and values in JavaScript objects or arrays.

Given an object or array obj, return an inverted version invertedObj where:
• Keys become values and values become keys
• For arrays, indices are treated as keys
• When multiple keys share the same value, the inverted object maps that value to an array of all corresponding keys

This problem simulates real-world scenarios like creating reverse lookup tables, building search indices, or transforming database query results for efficient access patterns.

Input & Output

example_1.py — Basic Object Inversion

$ Input: {"a": "1", "b": "2", "c": "3"}

› Output: {"1": "a", "2": "b", "3": "c"}

💡 Note: Simple one-to-one mapping where each value becomes a key mapped to its original key. No duplicates exist.

example_2.py — Handling Duplicates

$ Input: {"a": "1", "b": "2", "c": "1"}

› Output: {"1": ["a", "c"], "2": "b"}

💡 Note: Value "1" appears twice (keys "a" and "c"), so it maps to an array ["a", "c"]. Value "2" appears once, so it maps to string "b".

example_3.py — Array Input

$ Input: ["hello", "world", "hello"]

› Output: {"hello": ["0", "2"], "world": "1"}

💡 Note: Array indices become keys: index 0 and 2 have "hello", so "hello" maps to ["0", "2"]. Index 1 has "world", so "world" maps to "1".

Constraints

1 ≤ Object.keys(obj).length ≤ 10⁴
All values in the object are strings only
Keys can be any valid object key (string or number)
For arrays, indices are treated as string keys ("0", "1", etc.)

Visualization

Tap to expand

Understanding the Visualization

Original Structure

Start with object mapping keys to values

Single Pass Processing

For each key-value pair, add value->key to result

Handle Duplicates

When value already exists, convert to array or extend array

Complete Inversion

Final result has all values as keys, mapped to original keys

Key Takeaway

🎯 Key Insight: One-pass hash table approach efficiently handles both unique values and duplicates by checking existence and converting to arrays when needed.

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a one-pass hash table approach with O(n) time complexity. As we iterate through each key-value pair, we immediately build the inverted mapping by checking if the value already exists as a key in our result. For duplicate values, we handle them by converting single entries to arrays and appending to existing arrays.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Build the inverted mapping in a single pass through the data
Brute Force (Nested Loops)	O(n²)	O(n)	For each unique value, scan the entire object to find all keys with that value

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize an empty result object
Iterate through each key-value pair in the input
For each value, check if it already exists in result
If not exists: add value -> key mapping
If exists and current is string: convert to [existing, new]
If exists and current is array: append new key to array

Visualization

Tap to expand

Step-by-Step Walkthrough

Process First Pair

Add a->x as x->a in result

Process Second Pair

Add b->y as y->b in result

Handle Duplicate

c->x conflicts with existing x->a, convert to array

Final Result

Complete inverted object with proper duplicate handling

Code -

solution.c — C

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

#define MAX_SIZE 100
#define MAX_KEYS 10

typedef struct {
    char value[50];
    char keys[MAX_KEYS][50];
    int keyCount;
} InvertedEntry;

void invertObject(char keys[][50], char values[][50], int size) {
    InvertedEntry result[MAX_SIZE];
    int resultSize = 0;
    
    for (int i = 0; i < size; i++) {
        int found = -1;
        
        // Check if value already exists
        for (int j = 0; j < resultSize; j++) {
            if (strcmp(result[j].value, values[i]) == 0) {
                found = j;
                break;
            }
        }
        
        if (found == -1) {
            // First occurrence
            strcpy(result[resultSize].value, values[i]);
            strcpy(result[resultSize].keys[0], keys[i]);
            result[resultSize].keyCount = 1;
            resultSize++;
        } else {
            // Add to existing entry
            strcpy(result[found].keys[result[found].keyCount], keys[i]);
            result[found].keyCount++;
        }
    }
    
    // Print result
    for (int i = 0; i < resultSize; i++) {
        printf("%s: ", result[i].value);
        if (result[i].keyCount == 1) {
            printf("%s", result[i].keys[0]);
        } else {
            printf("[");
            for (int j = 0; j < result[i].keyCount; j++) {
                printf("%s", result[i].keys[j]);
                if (j < result[i].keyCount - 1) printf(", ");
            }
            printf("]");
        }
        printf("\n");
    }
}

int main() {
    char keys[3][50] = {"a", "b", "c"};
    char values[3][50] = {"1", "2", "1"};
    invertObject(keys, values, 3);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n key-value pairs with O(1) hash operations

✓ Linear Growth

Space Complexity

O(n)

Storage for the result object with at most n entries

⚡ Linearithmic Space

28.6K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler