Move Array Element

Prompt

/**
 * Write a function to move an array element from one position to another.
 *
 * Examples:
 *
 * console.log(move([10, 20, 30, 40, 50], 0, 2));
 * [20, 30, 10, 40, 50]
 *
 * console.log(move([10, 20, 30, 40, 50], -1, -2));
 * [10, 20, 50, 30, 40]
 *
 */

function move(arr, pos, shift) {
  // Some magic here
  return arr;
}

console.log(move([10, 20, 30, 40, 50], 0, 2));

Playground

Solution

Explanation

This problem looks simple at first glance, but there are a few tricky parts to handle. Let's break it down step by step.

Handling Negative Indices

The first challenge is dealing with negative indices. In JavaScript, arrays don't natively support negative indexing like Python does. So we need to convert negative indices to their positive equivalents:

let fromIndex = pos < 0 ? length + pos : pos;

If pos is -1 and the array has 5 elements, this gives us 5 + (-1) = 4, which is the index of the last element. Simple math, but easy to forget!

Calculating the New Position

Next, we figure out where the element should end up:

let toIndex = fromIndex + shift;

But wait - what if toIndex ends up being negative or larger than the array length? We need to wrap it around:

toIndex = ((toIndex % length) + length) % length;

This formula might look a bit intimidating, but it's a common pattern for handling wrap-around. The double modulo operation ensures the result is always positive and within bounds.

The Actual Move

Now for the fun part - actually moving the element. We use splice() twice:

1. Remove the element: arr.splice(fromIndex, 1) removes one element at fromIndex and returns it as an array. We use destructuring [element] to grab the actual value.

2. Insert at new position: arr.splice(toIndex, 0, element) inserts the element at toIndex without removing anything (that's what the 0 is for).

const [element] = arr.splice(fromIndex, 1);
arr.splice(toIndex, 0, element);

Why This Works

The beauty of this solution is that splice() handles all the heavy lifting. When you remove an element, the array automatically shifts to fill the gap. When you insert, everything shifts to make room. We're just telling the array where to remove from and where to insert to.

Dry Run

Let's walk through move([10, 20, 30, 40, 50], -1, -2):

1. Initial array: [10, 20, 30, 40, 50], length = 5
2. Convert negative index: pos = -1 → fromIndex = 5 + (-1) = 4
3. Calculate new position: toIndex = 4 + (-2) = 2
4. Remove element: We remove 50 from index 4 → array becomes [10, 20, 30, 40]
5. Insert element: We insert 50 at index 2 → array becomes [10, 20, 50, 30, 40]
6. Result: [10, 20, 50, 30, 40]

Notes

const [element] = arr.splice(fromIndex, 1);

Resources

• Array.prototype.splice()

• Remainder (%) Operator

• Destructuring Assignment