EasyDSAAsked in 20246 min read

Invert Object Keys

Q: Invert Object Keys

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Easy > **How to read this doc:** the real, easy-to-overlook collision behavior this question tests — what genuinely happens when two different keys share the SAME value — was verified directly: with `{a: "dup", b: "dup", c: "unique"}`, the inverted result correctly kept `b` (the LAST key seen with that value) for the `"dup"` entry, not `a`. ## 1. The problem, restated For every own key in the input object, create a NEW object where that value becomes a key, and the original key becomes its corresponding value — processing keys in their real, standard iteration order, so that if MULTIPLE keys share the same value, the LAST one processed correctly wins (since each assignment simply overwrites any earlier one for that shared, inverted key) — matching lodash's own well-known `_.invert` contract. ## 2. Clarifying questions a strong candidate asks | Question | Why it matters | | :--- | :

384 views

38 of 154

The problem

Problem, as an interviewer would state it: "Implement invert(obj) — swapping every key and value in a plain object, so that a value becomes a key and its original key becomes the new value, matching lodash's own well-known _.invert behavior."

Examples:

Code

invert({a: "x", b: "y", c: "z"}); // {x: "a", y: "b", z: "c"}

Clarifying questions expected:

If two different keys share the SAME value, which of the two original keys should genuinely win in the inverted result?
Should the original object remain completely untouched, with a genuinely NEW object returned?
What should happen to a value that is not naturally string-like, like a number — does it need to be coerced?

Code / implementation expected: Yes — real, direct proof of a basic key/value swap, a duplicate-value collision case, and confirmation the original object is never mutated.

object

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for practical JavaScript coding interviews. Difficulty: Easy

How to read this doc: the real, easy-to-overlook collision behavior this question tests — what genuinely happens when two different keys share the SAME value — was verified directly: with {a: "dup", b: "dup", c: "unique"}, the inverted result correctly kept b (the LAST key seen with that value) for the "dup" entry, not a.

1. The problem, restated

For every own key in the input object, create a NEW object where that value becomes a key, and the original key becomes its corresponding value — processing keys in their real, standard iteration order, so that if MULTIPLE keys share the same value, the LAST one processed correctly wins (since each assignment simply overwrites any earlier one for that shared, inverted key) — matching lodash's own well-known _.invert con

The solution is hidden so you can try first

6 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal, direct proof: invert() correctly swaps keys and values, with a duplicate-value collision correctly keeping the last key, and no mutation of the original

Practice

Discussion

Other approaches, follow-ups and how it went in real interviews.

No comments yet. Share how you would answer it.

Question 38 of 154 in JavaScript coding

Keep your momentum going.

Mark this question solved to track your progress, then take the next one while it is fresh.

All JavaScript coding questions

Up nextEasy→

Implement Your Own Array.prototype.reduceRight()

Continue