Create Object from Two Arrays - Practice Coding Problems

Create Object from Two Arrays - Problem

JavaScript Easy

You are given two arrays: keysArr containing potential object keys and valuesArr containing corresponding values. Your task is to merge these arrays into a single object where each key-value pair comes from keysArr[i] and valuesArr[i].

Key Rules:

Duplicate Prevention: If a key appears multiple times, only the first occurrence should be included in the final object
Type Conversion: All keys must be converted to strings using String()
Index Matching: keysArr[i] pairs with valuesArr[i]

This problem simulates creating a configuration object from separate key and value arrays, commonly seen in data processing and API responses.

Input & Output

example_1.py — Basic Case

$ Input: keysArr = ["a", "b", "c"], valuesArr = [1, 2, 3]

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

💡 Note: No duplicate keys, so all key-value pairs are included in the result object.

example_2.py — Duplicate Keys

$ Input: keysArr = ["a", "b", "a", "c"], valuesArr = [1, 2, 3, 4]

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

💡 Note: The key "a" appears at indices 0 and 2. Only the first occurrence (index 0) with value 1 is kept, the duplicate at index 2 with value 3 is ignored.

example_3.py — Type Conversion

$ Input: keysArr = [1, "1", 2], valuesArr = ["first", "second", "third"]

› Output: {"1": "first", "2": "third"}

💡 Note: The number 1 and string "1" both convert to the same string key "1". Only the first occurrence (number 1) is kept with value "first".

Constraints

0 ≤ keysArr.length = valuesArr.length ≤ 10⁴
keysArr[i] can be any type that can be converted to string
valuesArr[i] can be any valid JavaScript value
Both arrays will always have the same length

Visualization

Tap to expand

Understanding the Visualization

Initialize Tracking

Start with empty result object and Set to track processed keys

Process Each Pair

Convert key to string and check if we've seen it before

Add New Keys

If key is new, add to both tracking Set and result object

Skip Duplicates

If key already exists in Set, ignore this occurrence

Key Takeaway

🎯 Key Insight: Using a Hash Set for O(1) duplicate detection transforms an O(n²) nested loop problem into an optimal O(n) single-pass solution.

Asked in

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

The optimal solution uses a Hash Set to track seen keys in O(1) time, enabling duplicate detection during a single pass through the arrays. This achieves O(n) time complexity compared to the O(n²) brute force approach that checks each key against all previous keys.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Set (Optimal)	O(n)	O(n)	Use a Set to track seen keys while building the object in a single pass
Brute Force (Nested Loops)	O(n²)	O(1)	Check for duplicates by scanning all previous keys for each new key

One-Pass Hash Set (Optimal) — Algorithm Steps

Initialize an empty result object and a Set to track seen keys
For each index i in the arrays:
Convert keysArr[i] to string
Check if the key exists in the seen Set (O(1) lookup)
If not seen, add key to Set and add key-value pair to result
Return the result object

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty result object and empty Set

Process Each Key

Check Set membership in O(1) time

Add if New

Add to both Set and result if first occurrence

Skip if Duplicate

Skip if key already exists in Set

Code -

solution.c — C

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

#define MAX_KEYS 1000
#define MAX_STR_LEN 100

typedef struct {
    char key[MAX_STR_LEN];
    char value[MAX_STR_LEN];
} KeyValue;

int isKeySeen(char seenKeys[][MAX_STR_LEN], int seenCount, char* key) {
    for (int i = 0; i < seenCount; i++) {
        if (strcmp(seenKeys[i], key) == 0) {
            return 1;
        }
    }
    return 0;
}

int createObject(char keys[][MAX_STR_LEN], char values[][MAX_STR_LEN], int n, KeyValue result[]) {
    char seenKeys[MAX_KEYS][MAX_STR_LEN];
    int seenCount = 0;
    int resultSize = 0;
    
    for (int i = 0; i < n; i++) {
        if (!isKeySeen(seenKeys, seenCount, keys[i])) {
            strcpy(seenKeys[seenCount], keys[i]);
            seenCount++;
            
            strcpy(result[resultSize].key, keys[i]);
            strcpy(result[resultSize].value, values[i]);
            resultSize++;
        }
    }
    
    return resultSize;
}

int main() {
    printf("Optimal solution implemented\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through arrays with O(1) Set operations for duplicate checking

✓ Linear Growth

Space Complexity

O(n)

Set to store unique keys seen so far, plus the result object

⚡ Linearithmic Space

23.4K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Set (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler