0

I have an array with 7 items in it. I want to move a few items to a different index in the same order as it was in the original array. I have pasted in code snippet on whatever I tried so far.

let originalArray = ['a','b','c','d','e','f','g'];

let itemsToBeMoved = ['c','f','e'];

let newIndexToBeMoved = 4;

//expected result is ['a','b','d','c','e','f','g'];

let movableItemsIndex = [];
movableItemsIndex.push(originalArray.indexOf('c'));
movableItemsIndex.push(originalArray.indexOf('f'));
movableItemsIndex.push(originalArray.indexOf('e'));

//To be Moved items has to be sorted as in originalArray
movableItemsIndex.sort();

let itemsToBeMovedSorted = [originalArray[movableItemsIndex[0]],originalArray[movableItemsIndex[1]],originalArray[movableItemsIndex[2]]];

//Removing items before inserting to items to new position
while(movableItemsIndex.length) {
    originalArray.splice(movableItemsIndex.pop(), 1);
}
let newUpdatedArray = [...originalArray],j=0;
for(let i = newIndexToBeMoved ;i < originalArray.length ; i++){
  newUpdatedArray[i] = itemsToBeMovedSorted[j];
  j++;
}
console.log(newUpdatedArray);

Improve this question
3
  • splice them out, splice 'em back in again - developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… Commented Oct 14, 2020 at 12:43
  • what defines the insertion index, given that some of the elements before that index are to be removed (thereby changing its index)? In the context of searching for stuff would it make more sense to give the value of the element after which the moved elements are to be re-inserted? Commented Oct 14, 2020 at 12:50
  • The problem is that, Since i have to splice the items which have to be moved. The index of items in original Array changes. Now the index where i have to insert the items one after another is not valid after splicing. You can see the expected result in snippet i provided. Commented Oct 14, 2020 at 12:56

4 Answers 4

Reset to default
2

Assuming that all elements are unique:

let originalArray = ['a','b','c','d','e','f','g'];
let itemsToBeMoved = ['c','f','e'];

let newIndexToBeMoved = 4;

// find the value of the element the marks the insertion point
let insertBefore = originalArray[newIndexToBeMoved];

// in original sequence order, check for presence in the removal
// list, *and* remove them from the original array
let moved = [];
for (let i = 0; i < originalArray.length; ) {
    let value = originalArray[i];
    if (itemsToBeMoved.indexOf(value) >= 0) {
        moved.push(value);
        originalArray.splice(i, 1);
    } else {
        ++i;
    }
}

// find the new index of the insertion point
let insertionIndex = originalArray.indexOf(insertBefore);
if (insertionIndex < 0) {
    insertionIndex = originalArray.length;
}

// and add the elements back in
originalArray.splice(insertionIndex, 0, ...moved);

console.log(originalArray);

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

Sorry, I dint test all scenarios before accepting. I am sorry for that. If I change itemsToBeMoved = ['f','e'] & newIndexToBeMoved = 6; then output is ["e", "f", "a", "b", "c", "d", "g"], It should have been ["a", "b", "c", "d", "g","e", "f", ]
@SsNewbie you have a (lack of) specification problem then, because in the first example the d after which you wanted the elements inserted was the element with index 3 (zero indexed), not the fourth, i.e. you're inserting between elements 3 and 4. g is the sixth element. My code produces the desired output if you specify newIndexToBeMoved = 7 (i.e. one after the position of the g).
NB: code updated to allow for the edge conditions at either end of the array.
@Alnatik : Yeah.. So if (newIndexToBeMoved = 6) (last index), Then have to make it 6 + 1, To make it work. Also What I tried is with your previous code(before previous update) (originalArray.splice(newIndexToBeMoved === (originalArrayClone.length -1) ? (originalArray.length) : insertionIndex, 0, ...moved);) with originalArrayClone is clone of originalArray before splicing it.
AFAICS my current code works fine, but you can't get the results you expect by specifying 4 (per the question) and 6 per your comment - the latter has to be 7 for it to be consistent with the 4.
1

This can be solved many ways, but here is a quick run-down of what could be done:

  1. First, you could create a "present" map (based on the positions in the source array) for the items to be moved
  2. Now, filter the array, removing the items, but keeping track whether they are present
  3. Splice the (sorted) present, filtered-out, values into the altered array at the desired position (based on the index in the source array)

const move = (arr, items, index) => {
  const present = new Map(items.map(item => [item, arr.indexOf(item)]));
  const altered = arr.filter(item => !present.has(item));
  altered.splice(arr.indexOf(arr[index - 1]), 0, ...([...present.entries()]
    .filter(([k, v]) => v !== -1)
    .sort(([, k1], [, k2]) => k1 - k2)
    .map(([k, v]) => k)));
  return altered;
}

const moved = move(['a','b','c','d','e','f','g'], ['c','f','e'], 4);

console.log(moved);
.as-console-wrapper { top: 0; max-height: 100% !important; }

Improve this answer

7 Comments

this does not produce the OP's desired output sequence.
@Alnitak I had to sort the values and subtract one from the index, because it looks like their index starts at 1 rather than 0. Thanks for the feedback.
I believe the index starts at 0, but it reflects the insertion point within the original sequence, and therefore the ultimate insertion point will depend on how many of the removed elements are from preceding elements.
What exactly are you sorting on, BTW? The values, or their positions? Without comments it's hard to tell, but if you're sorting on values the OP made no such requirement. The requirement was that the removed elements appear in the same order as in the original array, which just happens to be sorted.
@Alnitak It's because I used a map, but I didn't retain the original index sequence, so I think your response takes care of this... I set up the present map to store the original positions. That way I can filter-out the non-present items and then re-sort them later.
|
0

Here's a way to do it with typescript and generics. It does not mutate the array, it's very fast (used the conclusions of this article to make it).

When moving items to a new position, there is always a range of items affected by the move. By affected, I mean that within that range, all items will have to move. I calculate the min/max of the range, any items outside that range will simply be copied from the old to new array.

Then, depending whether the items are moved up or down in the array, I copy each items from old to new array taking into account the offset of the move.

export const arrayMove = <ItemType>({
    arr,
    from,
    to,
    movedItemsCount = 1,
}: {
    arr: ItemType[]
    from: number
    to: number
    movedItemsCount?: number
}) => {
    if (from === to) return arr

    const minAffected = Math.min(from, to)
    const maxAffected = Math.max(to, from + movedItemsCount - 1)
    const pushedItemsCount = maxAffected - minAffected + 1 - movedItemsCount

    const newArr: ItemType[] = []
    newArr.length = arr.length

    for (let i = 0; i < arr.length; i++) {
        if (i < minAffected || i > maxAffected) {
            // When i is outside the affected range,
            // items are identical in new and old arrays
            newArr[i] = arr[i]
        } else {
            // Moving items down
            if (to > from) {
                if (i < to - movedItemsCount + 1) {
                    // Write pushed items
                    newArr[i] = arr[i + movedItemsCount]
                } else {
                    // Write moved items
                    newArr[i] = arr[i - pushedItemsCount]
                }
            } else {
                // Moving items up
                if (i < to + movedItemsCount) {
                    // Write moved items
                    newArr[i] = arr[i + pushedItemsCount]
                } else {
                    // Write pushed items
                    newArr[i] = arr[i - movedItemsCount]
                }
            }
        }
    }

    return newArr
}
Improve this answer

Comments

-1

Try this:

const originalArray = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];

const itemsToBeMoved = ['c', 'f', 'e'];

const newIndexToBeMoved = 4;

originalArray.splice(newIndexToBeMoved, 0, itemsToBeMoved)

console.log(originalArray.flat())

Improve this answer

1 Comment

The elements to be moved are not a contiguous group. They need to be removed individually, but can then be reinserted en-masse.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.