JavaScript - Determine all possible ways a group of values can be removed from a sequence

We are required to write a JavaScript function that determines how many different ways we can remove a group of values from a sequence, leaving the original sequence in order (stable), and making sure to remove only one instance of each value from the original sequence.

For example ? If the sequence array is ?

const arr = [1, 2, 1, 3, 1, 4, 4];

And the array to be removed is ?

const arr2 = [1, 4, 4];

Then there are three possible ways of doing this without disrupting the order of elements ?

1 --> [2, 1, 3, 1]
2 --> [1, 2, 3, 1]  
3 --> [1, 2, 1, 3]

Therefore, our function should output 3 for these sequences.

Algorithm Overview

The solution works by:

• Finding all positions where each value to be removed appears in the original array
• Generating valid combinations while maintaining order constraints
• Counting the total number of valid removal combinations

Implementation

const arr = [1, 2, 1, 3, 1, 4, 4];
const arr2 = [1, 4, 4];

const possibleRemovalCombinations = (original, part) => {
    const sorter = (a, b) => a - b;
    part.sort(sorter);
    let place = [];
    
    // Create empty arrays for each element to be removed
    part.forEach(el => {
        place[el] = []
    });
    
    // Find all positions of elements to be removed in original array
    original.forEach((el, index) => {
        if(place[el]){
            place[el].push(index);
        }
    });
    
    // Create connection array with positions for each element
    let connection = part.map(el => place[el].slice());
    
    // Apply forward constraints (left to right)
    for(let i = 1; i < connection.length; i++){
        if (part[i - 1] != part[i]){
            continue;
        }
        let left = connection[i - 1][0];
        while(connection[i][0] <= left){
            connection[i].shift();
        };
    };
    
    // Apply backward constraints (right to left)
    for (let i = connection.length - 2; i >= 0; i--) {
        if(part[i] != part[i + 1]){
            continue;
        }
        let right = connection[i + 1][connection[i + 1].length - 1];
        while(connection[i][connection[i].length - 1] >= right){
            connection[i].pop();
        };
    };
    
    // Generate all valid combinations
    const combineArray = (step, prev, combination) => {
        for (let i = 0; i < connection[step].length; i++) {
            let curr = connection[step][i];
            if(prev >= curr && original[prev] == original[curr]){
                continue;
            }
            if(step + 1 == connection.length){
                combinations.push(combination.concat([curr]))
            }
            else {
                combineArray(step + 1, curr, combination.concat([curr]));
            };
        };
    };
    
    let combinations = [], res = [];
    combineArray(0, -1, []);
    
    // Process combinations to create result arrays
    for (let i = 0; i < combinations.length; i++) {
        let copy = original.slice();
        combinations[i].forEach(el => copy[el] = undefined);
        res[i] = copy.filter(el => el !== undefined);
    };
    
    return res.length;
};

console.log(possibleRemovalCombinations(arr, arr2));

Output

3

How It Works

The algorithm maintains order stability by:

1. Position Mapping: Records all indices where each target value appears
2. Constraint Application: Ensures duplicate elements are removed in proper sequence
3. Combination Generation: Uses recursive backtracking to find all valid removal patterns
4. Result Construction: Creates the final arrays by removing selected elements

Key Points

• The function preserves the original order of remaining elements
• Each element instance is removed exactly once per combination
• Duplicate values in the removal array create multiple valid combinations
• Time complexity depends on the number of duplicate elements and their positions

Conclusion

This solution efficiently calculates all possible ways to remove specific values from an array while maintaining order stability. It handles duplicate values correctly by considering all valid position combinations.