What is the best way to compare consecutive string elements within an array using JavaScript?

Question

What is the best way to compare consecutive string elements within an array using JavaScript?

Given an array of words, I want to identify pairs of opposite directions and remove them from the array, returning a new modified array.

For instance:

let words = ["up", "right", "left", "down", "left", "down", "up", "left"]

should result in:

newWords = ["left", "left"]

Here's my current approach. However, I am encountering an issue where it gives undefined.

let words = ["up", "right", "left", "down", "left", "down", "up", "left"]

function checkOpposite(pair) {
  let upDown = ["up", "down"]
  let downUp = ["down", "up"]
  let rightLeft = ["right", "left"]
  let leftRight = ["left", "right"]
  
  for (var i = 0; i < pair.length - 1; i++) {
    if (pair[i] + pair[i + 1] === upDown) 
    if (pair[i] + pair[i + 1] === downUp)
    if (pair[i] + pair[i + 1] === rightLeft)
    if (pair[i] + pair[i + 1] === leftRight) {
      return true
    }
  }
}

function filterDirections(words) {
  words.filter(checkOpposite)
}

javascript arrays

Answer 1

Answer №1

To achieve a stable array, filter it until the size remains constant.

let
    array = ["N", "E", "W", "S", "W", "S", "N", "W"],
    temp;

do {
    let index = -1;
    temp = array;
    array = temp.filter((v, i, { [i + 1]: next }) => {
        if (i === index) return false;
        if (
            v === 'N' && next === 'S' || v === 'S' && next === 'N' ||
            v === 'E' && next === 'W' || v === 'W' && next === 'E'
        ) {
            index = i + 1;
            return false;
        }
        return true;
    });
} while (temp.length !== array.length)

console.log(array);

Answer 2

To achieve a stable array, filter it until the size remains constant.

let
    array = ["N", "E", "W", "S", "W", "S", "N", "W"],
    temp;

do {
    let index = -1;
    temp = array;
    array = temp.filter((v, i, { [i + 1]: next }) => {
        if (i === index) return false;
        if (
            v === 'N' && next === 'S' || v === 'S' && next === 'N' ||
            v === 'E' && next === 'W' || v === 'W' && next === 'E'
        ) {
            index = i + 1;
            return false;
        }
        return true;
    });
} while (temp.length !== array.length)

console.log(array);

Answer 3

Answer №2

function eliminateDirections(array) {
    var nCount = 0, eCount = 0, sCount = 0, wCount = 0;
    var result = "";

    for (var direction of array) {
        switch (direction) {
            case "N":
                nCount++;
                break;
            case "E":
                eCount++;
                break;
            case "S":
                sCount++;
                break;
            case "W":
                wCount++;
                break;
        }
    }

    if (eCount > wCount) { eCount -= wCount; wCount = 0; }
    else { wCount -= eCount; eCount = 0; }

    if (nCount > sCount) { nCount -= sCount; sCount = 0; }
    else { sCount -= nCount; nCount = 0; }

    return result + "N".repeat(nCount) + "S".repeat(sCount) + "E".repeat(eCount) + "W".repeat(wCount);
}

let directions = ["N", "E", "W", "S", "W", "S", "N", "W"];
console.log(eliminateDirections(directions));

Insight: By keeping tally of each direction and eliminating opposite pairs, the function efficiently reduces the list of directions. The time complexity is O(n), but further exploration may reveal a faster solution.

Answer 4

function eliminateDirections(array) {
    var nCount = 0, eCount = 0, sCount = 0, wCount = 0;
    var result = "";

    for (var direction of array) {
        switch (direction) {
            case "N":
                nCount++;
                break;
            case "E":
                eCount++;
                break;
            case "S":
                sCount++;
                break;
            case "W":
                wCount++;
                break;
        }
    }

    if (eCount > wCount) { eCount -= wCount; wCount = 0; }
    else { wCount -= eCount; eCount = 0; }

    if (nCount > sCount) { nCount -= sCount; sCount = 0; }
    else { sCount -= nCount; nCount = 0; }

    return result + "N".repeat(nCount) + "S".repeat(sCount) + "E".repeat(eCount) + "W".repeat(wCount);
}

let directions = ["N", "E", "W", "S", "W", "S", "N", "W"];
console.log(eliminateDirections(directions));

Insight: By keeping tally of each direction and eliminating opposite pairs, the function efficiently reduces the list of directions. The time complexity is O(n), but further exploration may reveal a faster solution.

Answer 5

Answer №3

One of the main issues is that you are receiving undefined because there is no return statement in your code.

function newDirections(arr) { arr.filter(checkForOpposites) } // <-- no return so undefined

Another issue lies in the logic of your code, as it implies that every element must be equal to each other which is not achievable. The current structure of your code is as follows:

if (arr[i] + arr[i + 1] === nOpp) {
  if (arr[i] + arr[i + 1] === sOpp) {
    if (arr[i] + arr[i + 1] === eOpp) {
      if (arr[i] + arr[i + 1] === wOpp) {
        return true;
      }
    }
  }
}

Moreover, using filter results in multiple loops and internal looping within it which is not efficient. Consider utilizing a loop for a more effective approach.

var opposites = {
  N: 'S',
  S: 'N',
  E: 'W',
  W: 'E',
};

function newDirections(orgArr) {
  var arr = orgArr.slice();
  var i = 0;
  while (i < arr.length - 1) {
    var dir = arr[i];
    var nextDir = arr[i + 1];
    if (opposites[dir] === nextDir) {
      arr.splice(i, 2); 
      if (i > 0) {
        i--;
      }
    } else {
      i++;
    }
  }
  return arr;
}

const arr = ["N", "E", "W", "S", "W", "S", "N", "W"];
console.log(newDirections(arr));

console.log(newDirections(["N", "S", "E", "W", "W", "S"]));
console.log(newDirections(["E", "N", "S", "E", "W", "W", "S"]));
console.log(newDirections(["E", "E", "W", "N", "S", "E", "W", "W"]));

Answer 6

One of the main issues is that you are receiving undefined because there is no return statement in your code.

function newDirections(arr) { arr.filter(checkForOpposites) } // <-- no return so undefined

Another issue lies in the logic of your code, as it implies that every element must be equal to each other which is not achievable. The current structure of your code is as follows:

if (arr[i] + arr[i + 1] === nOpp) {
  if (arr[i] + arr[i + 1] === sOpp) {
    if (arr[i] + arr[i + 1] === eOpp) {
      if (arr[i] + arr[i + 1] === wOpp) {
        return true;
      }
    }
  }
}

Moreover, using filter results in multiple loops and internal looping within it which is not efficient. Consider utilizing a loop for a more effective approach.

var opposites = {
  N: 'S',
  S: 'N',
  E: 'W',
  W: 'E',
};

function newDirections(orgArr) {
  var arr = orgArr.slice();
  var i = 0;
  while (i < arr.length - 1) {
    var dir = arr[i];
    var nextDir = arr[i + 1];
    if (opposites[dir] === nextDir) {
      arr.splice(i, 2); 
      if (i > 0) {
        i--;
      }
    } else {
      i++;
    }
  }
  return arr;
}

const arr = ["N", "E", "W", "S", "W", "S", "N", "W"];
console.log(newDirections(arr));

console.log(newDirections(["N", "S", "E", "W", "W", "S"]));
console.log(newDirections(["E", "N", "S", "E", "W", "W", "S"]));
console.log(newDirections(["E", "E", "W", "N", "S", "E", "W", "W"]));

Answer 7

Answer №4

To convert directions into vectors, add the vectors together, and then transform the resulting vector back into a list of directions:

var arr = ["N", "E", "W", "S", "W", "S", "N", "W"]

var vecMap = {
    N: [1,0],
    E: [0,1],
    S: [-1,0],
    W: [0,-1]
};

var revMap = [
    ['N','S'],
    ['E','W']
];

const dir2Vec = dir => vecMap[dir];
const vec2Dir = (acc, cur, i) => {
    // Determine the direction based on the reverse map
    const dir = revMap[i][+(cur < 0)];
    // Create an array with n items where n is the length of the vector
    const dup = Array.from({length: Math.abs(cur)}).fill(dir);
    return [...acc, ...dup]
}
const sumVec = (a,b) => [a[0]+b[0], a[1]+b[1]];

const res = arr
.map(dir2Vec)
.reduce(sumVec)
.reduce(vec2Dir, [])

console.log(res)

Answer 8

To convert directions into vectors, add the vectors together, and then transform the resulting vector back into a list of directions:

var arr = ["N", "E", "W", "S", "W", "S", "N", "W"]

var vecMap = {
    N: [1,0],
    E: [0,1],
    S: [-1,0],
    W: [0,-1]
};

var revMap = [
    ['N','S'],
    ['E','W']
];

const dir2Vec = dir => vecMap[dir];
const vec2Dir = (acc, cur, i) => {
    // Determine the direction based on the reverse map
    const dir = revMap[i][+(cur < 0)];
    // Create an array with n items where n is the length of the vector
    const dup = Array.from({length: Math.abs(cur)}).fill(dir);
    return [...acc, ...dup]
}
const sumVec = (a,b) => [a[0]+b[0], a[1]+b[1]];

const res = arr
.map(dir2Vec)
.reduce(sumVec)
.reduce(vec2Dir, [])

console.log(res)

Answer 9

Answer №5

Comparing arrays using

if (arr[i] + arr[i + 1] === nOpp)

is not the correct way. Using === will compare if both sides are Array type objects, not their content. To compare array contents, use other methods.

To test this in node.js CLI, run this code:

const nOpp = ["N", "S"];
console.log(nOpp === ["N", "S"]);

You'll see false printed in the console.

For more info, refer to: How to compare arrays in JavaScript?

Nesting if statements like this is equivalent to successive AND conditions:

    if (arr[i] + arr[i + 1] === nOpp) 
    if (arr[i] + arr[i + 1] === sOpp)
    if (arr[i] + arr[i + 1] === eOpp)
    if (arr[i] + arr[i + 1] === wOpp) {
     ...
    }

This means each subsequent if is only checked if the previous one is true.

My revised version simplifies the logic based on your initial question and desired outcome. Here's the code snippet:

let arr = ["N", "E", "W", "S", "W", "S", "N", "W"]
const opposites = [
  ["N", "S"],
  ["W", "E"],
];

const checkForOpposites = data => {
  const result = [];
  data.forEach((v0, i, a) => {
    let oppositeFound = false;
    opposites.forEach(o => {
      if (v0 != a[i+1] && o.includes(v0) && o.includes(a[i+1])) {
        oppositeFound = true
        result.push(i, i+1);
      }
    });
  });
  return result;
}

const cleanOpposites = data => {
  let result = data;
  let n = [];
  do {
    n = checkForOpposites(result);
    if (n.length > 0) {
      result = result.reduce((accum, curr, i) => {
        if (!n.includes(i)) {
          accum.push(curr);
        }
        return accum;
      }, []);
    }
  } while (n.length > 0);
  
  return result;
}

const r0 = cleanOpposites(arr);
console.log(arr);
console.log(r0);

The cleaning process must be recursive as shown above. This approach ensures unwanted elements are removed iteratively until no further matches are found.

Though the code can be optimized, this gives you an idea of how to achieve the desired result.

Answer 10

Comparing arrays using

if (arr[i] + arr[i + 1] === nOpp)

is not the correct way. Using === will compare if both sides are Array type objects, not their content. To compare array contents, use other methods.

To test this in node.js CLI, run this code:

const nOpp = ["N", "S"];
console.log(nOpp === ["N", "S"]);

You'll see false printed in the console.

For more info, refer to: How to compare arrays in JavaScript?

Nesting if statements like this is equivalent to successive AND conditions:

    if (arr[i] + arr[i + 1] === nOpp) 
    if (arr[i] + arr[i + 1] === sOpp)
    if (arr[i] + arr[i + 1] === eOpp)
    if (arr[i] + arr[i + 1] === wOpp) {
     ...
    }

This means each subsequent if is only checked if the previous one is true.

My revised version simplifies the logic based on your initial question and desired outcome. Here's the code snippet:

let arr = ["N", "E", "W", "S", "W", "S", "N", "W"]
const opposites = [
  ["N", "S"],
  ["W", "E"],
];

const checkForOpposites = data => {
  const result = [];
  data.forEach((v0, i, a) => {
    let oppositeFound = false;
    opposites.forEach(o => {
      if (v0 != a[i+1] && o.includes(v0) && o.includes(a[i+1])) {
        oppositeFound = true
        result.push(i, i+1);
      }
    });
  });
  return result;
}

const cleanOpposites = data => {
  let result = data;
  let n = [];
  do {
    n = checkForOpposites(result);
    if (n.length > 0) {
      result = result.reduce((accum, curr, i) => {
        if (!n.includes(i)) {
          accum.push(curr);
        }
        return accum;
      }, []);
    }
  } while (n.length > 0);
  
  return result;
}

const r0 = cleanOpposites(arr);
console.log(arr);
console.log(r0);

The cleaning process must be recursive as shown above. This approach ensures unwanted elements are removed iteratively until no further matches are found.

Though the code can be optimized, this gives you an idea of how to achieve the desired result.

What is the best way to compare consecutive string elements within an array using JavaScript?

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Similar questions

Modify the tooltip of the selected item in an ng-repeat loop in AngularJS

Having trouble simulating a custom Axios Class in JavaScript/TypeScript

Refreshing an iFrame in NextJS from a different component

Vue - Triggering @change event for file input element when files are set programmatically using ref instead of drag and drop upload

Dealing with the state of an array of checkboxes: What you need to know

"Exploring the power of asynchronous operations in NodeJS using Q

How to delete an element from an array using PHP

Character count in textarea does not work properly when the page is first loaded

Set checkbox variable to undefined at all times

Organize the array of objects

Using PHP, assign a reference to a class member

The concept of strict aliasing and the implementation of flexible array members

Determining the browser width's pixel value to enhance responsiveness in design

"Using Node.js Express 4.4 to efficiently upload files and store them in a dynamically

Maintain the state of the previous page in Vue to ensure continuity

Unusual behavior observed with AngularJS checkboxes

Issue with AngularJS: Dynamically generated tab does not become active or selected

Storing deeply nested arrays of objects with Mongoose leads to MongoDB storing empty objects

Utilize Quasar CSS breakpoints within Vue expressions for responsive design

Switch the array's value if the key is a match?