Remove an array of words from given string in the most efficient way

Question

I want the most efficient (in case of speed) solution to remove array of given words from the given string:

So far I have this not working solution:

const excludeWordList = ['the', 'in', 'a', 'an'];

run("the wall into")
run("paintings covered the wall another words into this")

function run(speech) {

    for(let a = 0; a < excludeWordList.length; a++) {
        speech = speech.replaceAll(excludeWordList[a], '');
    }
    console.log(speech);
}

As you see the code has three major issues:

It removes characters inside the words not just the single words
The result is not a trimmed string we have extra spaces inside words of the result too
The code is not the most efficient way I think!!!, because I need to loop through all the excludeWordList array.

I wrote my function as my and as you see the Gainza function is the most efficient function in this case:

Aviad · Accepted Answer · 2021-07-12 16:27:34Z

2

I'd use the a filter & set approach to minimize computation time (instead of includes or indexOf that iterate the whole array)

const excluded = new Set(['the', 'in', 'a', 'an']);


function run(speech) {
    return speech.split(' ')
           .filter(word => !excluded.has(word))
           .join(' ');
}


run("the wall into")
run("paintings covered the wall another words into this")

edited Jul 12, 2021 at 16:27

answered Jul 12, 2021 at 16:23

Aviad

3,6043 gold badges19 silver badges23 bronze badges

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

Comments

Cohars · Accepted Answer · 2021-07-12 16:39:02Z

2

Here's a way that doesn't loop, replaces all excluded words with a single regex, and finished up with a trim and extra space cleanup. This should be the fasted method. You can map the array into a Regex and preserve word boundaries \b, which have to be escaped when building it dynamically

const excludeWordList = ['the', 'in', 'a', 'an'];
const reg = new RegExp(excludeWordList.map(w => `\\b${w}\\b`).join('|'), 'g')

run("the wall into")
run("paintings covered the wall another words into this")

function run(speech) {
  speech = speech.replaceAll(reg, '').trim().replace(/\s\s+/g, ' ');
  console.log(speech);
}

edited Jul 12, 2021 at 16:39

Cohars

4,0501 gold badge34 silver badges51 bronze badges

answered Jul 12, 2021 at 16:30

Kinglish

23.7k4 gold badges25 silver badges43 bronze badges

Comments

Martin Gainza · Accepted Answer · 2021-07-12 16:21:34Z

1

const excludeWordList = ['the', 'in', 'a', 'an'];

run("the wall into")
run("paintings covered the wall another words into this")

function run(speech) {

    const result = speech.split(' ').filter(word=>!excludeWordList.includes(word)).join(' ')
    console.log(result);
}

answered Jul 12, 2021 at 16:21

Martin Gainza

1,42714 silver badges24 bronze badges

5 Comments

Barmar Over a year ago

If the word list is large, it would be more efficient to convert it to a Set first, to avoid all the sequential searching in includes

Aviad Over a year ago

Agree w/ @Barmar. This includes is "heavy" on long lists an won't query in O(1)

Sara Ree Over a year ago

His solution has the best performance why?

Sara Ree Over a year ago

I used for loop in my solution and our solution is very similar, you used filter but your solution is doing better almost every time. I thought for loop has far better performance than filter method Am I wrong???

Martin Gainza Over a year ago

@SaraRee It took 2 years but today I can answer, my code is faster thanks to functional programming, since in a for loop you are occupying more memory space than an anonymous function.

Tushar Shahi · Accepted Answer · 2021-07-12 16:29:41Z

1

You can try using split() and filter().

Edit: indexOf() complexity is O(N) because of linear search. Since we have a fixed set of words we want to exclude, converting to a set is ideal.

new Set() is also O(N), but since it is being done only once and your run() will be called more often it makes sense here. With set, .has() has O(1) complexity.

const excludeWordList = ['the', 'in', 'a', 'an'];

const excludeWordSet = new Set(excludeWordList);

run("the wall into")
run("paintings covered the wall another words into this")

function run(speech) {
speech = speech.split(' ').filter((a) => {
return (!excludeWordSet.has(a))
}).join(' ');
  
console.log(speech);
}

filter() still has O(N) complexity. join() has O(N). so this is still O(N^2), same as your initial attempt.

edited Jul 12, 2021 at 16:29

answered Jul 12, 2021 at 16:24

Tushar Shahi

21.6k2 gold badges25 silver badges48 bronze badges

2 Comments

Aviad Over a year ago

indexOf is the same as includes and will consume much time on large sets

Tushar Shahi Over a year ago

Thanks for that. Using set now.

customcommander · Accepted Answer · 2021-07-12 16:44:13Z

1

The problem with a solution using whitespaces as word separator is that it will most likely fail when you use punctuation for example e.g.

'the, Beattles'.split(' ').includes('the')
//=> false

Instead you should use \b (word boundary):

const excludes = ['the', 'in', 'a', 'an'];
const re = new RegExp('\\b(?:'+excludes.join('|')+')\\b', 'g');

console.log("the.wall.into".replace(re, ''));
console.log("paintings covered the, wall another words into this".replace(re, ''));

edited Jul 12, 2021 at 16:44

answered Jul 12, 2021 at 16:38

customcommander

19.3k6 gold badges70 silver badges97 bronze badges

Collectives™ on Stack Overflow

Remove an array of words from given string in the most efficient way

5 Answers 5

Comments

Comments

5 Comments

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

Comments

Comments

5 Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related