Retrieving JavaScript array elements following the repeated appearance of a specific element

Question

Retrieving JavaScript array elements following the repeated appearance of a specific element

I have an array in JavaScript which looks like this:

var myArray = ['a', 'x', 'b', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'];

I am interested in extracting elements from the array that come after two consecutive occurrences of a specific element.

For example, in the given array, I want to retrieve all elements that follow consecutive instances of 'x', 'x'

Therefore, the desired output would be:

'p'
'b'

Although I have found a solution to achieve this:

var arrLength = myArray.length;
for (var i = 0; i < arrLength; i++) {
    if(i+2 < arrLength && myArray[i] == 'x' && myArray[i+1] == 'x') {
        console.log(myArray[i+2]);
    }
};

While this solution works, it is not very generic.

For instance, if I need to identify three consecutive occurrences, I would need to add another condition within the if statement for myArray[i+2] == 'x' and so forth.

Is there a more efficient approach to fetching these elements?

javascript arrays

Answer 1

Answer №1

To tackle this problem in a functional manner, recursion is the way to go. By utilizing an ES6 spread operator, you can closely mimic the conciseness of a truly 'functional' language :-)

let myArray = ['a', 'x', 'b', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'];

function reducer(acc, xs) {
    if (xs.length > 2) {
        if (xs[0] === xs[1]) {
            // add the third element to accumulator
            // remove first three elements from xs
            // return reducer([xs[2], ...acc], xs.slice(3));
            // or per Nina's question below
            return reducer([xs[2], ...acc], xs.slice(1));
        } else {
            // remove first element from xs and recurse
            return reducer(acc, xs.slice(1))
        }
    } else {
        return acc;
    }
}

console.log(reducer([], myArray));

Answer 2

To tackle this problem in a functional manner, recursion is the way to go. By utilizing an ES6 spread operator, you can closely mimic the conciseness of a truly 'functional' language :-)

let myArray = ['a', 'x', 'b', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'];

function reducer(acc, xs) {
    if (xs.length > 2) {
        if (xs[0] === xs[1]) {
            // add the third element to accumulator
            // remove first three elements from xs
            // return reducer([xs[2], ...acc], xs.slice(3));
            // or per Nina's question below
            return reducer([xs[2], ...acc], xs.slice(1));
        } else {
            // remove first element from xs and recurse
            return reducer(acc, xs.slice(1))
        }
    } else {
        return acc;
    }
}

console.log(reducer([], myArray));

Answer 3

Answer №2

An efficient method for identifying specific patterns within an array.

function findPattern(array, pattern) {
    return array.reduce(function (result, element, index) {
        if (index >= pattern.length && pattern.every(function (p, j) {
            return p === array[index + j - pattern.length];
        })) {
            result.push(element);
        }
        return result;
    }, []);
}

function displayOutput(output) {
    document.write('<pre>' + JSON.stringify(output, 0, 4) + '</pre>');
}

displayOutput(findPattern(['a', 'x', 'x', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'], ['x', 'x']));
displayOutput(findPattern(['a', 'x', 'b', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'], ['a', 'x', 'b']));
displayOutput(findPattern(['a', 'b', 'c', 'd', 'z', 'y', 'a', 'b', 'c', 'd', 'x', 'x'], ['a', 'b', 'c', 'd']));
displayOutput(findPattern([41, 23, 3, 7, 8, 11, 56, 33, 7, 8, 11, 2, 5], [7, 8, 11]));

Answer 4

An efficient method for identifying specific patterns within an array.

function findPattern(array, pattern) {
    return array.reduce(function (result, element, index) {
        if (index >= pattern.length && pattern.every(function (p, j) {
            return p === array[index + j - pattern.length];
        })) {
            result.push(element);
        }
        return result;
    }, []);
}

function displayOutput(output) {
    document.write('<pre>' + JSON.stringify(output, 0, 4) + '</pre>');
}

displayOutput(findPattern(['a', 'x', 'x', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'], ['x', 'x']));
displayOutput(findPattern(['a', 'x', 'b', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'], ['a', 'x', 'b']));
displayOutput(findPattern(['a', 'b', 'c', 'd', 'z', 'y', 'a', 'b', 'c', 'd', 'x', 'x'], ['a', 'b', 'c', 'd']));
displayOutput(findPattern([41, 23, 3, 7, 8, 11, 56, 33, 7, 8, 11, 2, 5], [7, 8, 11]));

Answer 5

Answer №3

One approach you could consider is as follows:

var myArray = ['a', 'x', 'b', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'];

function search(ch, times) {
  var splitStr = "";  
  for(var i = 0; i < times; i++) {
   splitStr += ch;
  } // This generates the split string xx in the given example.
  var str = myArray.join(''); // Combines array items into a single string
  var array = str.split(splitStr); // Splits the string based on the split string
  var result = {};
  // Iterates over the array starting from index 1 to ignore the string before the split
  for (var i = 1 ; i < array.length; i++) { 
     if(array[i] !== "") {
        result[array[i].substring(0,1)] = ''; // Uses a map to prevent duplicate values
     }
  }
  
  return Object.keys(result); // Returns the keys
}

console.dir(search('x',2));

Answer 6

One approach you could consider is as follows:

var myArray = ['a', 'x', 'b', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'];

function search(ch, times) {
  var splitStr = "";  
  for(var i = 0; i < times; i++) {
   splitStr += ch;
  } // This generates the split string xx in the given example.
  var str = myArray.join(''); // Combines array items into a single string
  var array = str.split(splitStr); // Splits the string based on the split string
  var result = {};
  // Iterates over the array starting from index 1 to ignore the string before the split
  for (var i = 1 ; i < array.length; i++) { 
     if(array[i] !== "") {
        result[array[i].substring(0,1)] = ''; // Uses a map to prevent duplicate values
     }
  }
  
  return Object.keys(result); // Returns the keys
}

console.dir(search('x',2));

Answer 7

Answer №4

One way to tackle this issue is by using a simple iterative approach. We can keep track of consecutive elements in an array called consecutive. Whenever the length of this array reaches 2, we print out the next element and reset the consecutive array.

var arr = ['a', 'x', 'b', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'];

var REPEATS_NEEDED = 2;

var consecutive = [arr[0]];
for (var i = 1; i < arr.length; i++) {
    if (consecutive.length === REPEATS_NEEDED) {
        console.log(arr[i]);
        consecutive = [arr[i]];
        continue;
    }

    // Check if the current element should be added to or reset the 'consecutive' array
    if (arr[i] === consecutive[0]) {
        consecutive.push(arr[i]);
    } else {
        consecutive = [arr[i]];
    }
};

Answer 8

One way to tackle this issue is by using a simple iterative approach. We can keep track of consecutive elements in an array called consecutive. Whenever the length of this array reaches 2, we print out the next element and reset the consecutive array.

var arr = ['a', 'x', 'b', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'];

var REPEATS_NEEDED = 2;

var consecutive = [arr[0]];
for (var i = 1; i < arr.length; i++) {
    if (consecutive.length === REPEATS_NEEDED) {
        console.log(arr[i]);
        consecutive = [arr[i]];
        continue;
    }

    // Check if the current element should be added to or reset the 'consecutive' array
    if (arr[i] === consecutive[0]) {
        consecutive.push(arr[i]);
    } else {
        consecutive = [arr[i]];
    }
};

Answer 9

Answer №5

To enhance your code, consider implementing a new function called isItGood:

var myArray = ['a', 'x', 'b', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'];
var arrLength = myArray.length;
for (var i = 0; i < arrLength; i++) {
    isItGood(myArray, i, 'x', 2);
};

function isItGood(arr, i, elem, total) {
    for ( var j = 0 ; j < total ; j++ ) {
        if ( i + total >= arr.length || arr[i+j] != elem ) {
            return;
        }
    }
    console.log(arr[i+total]);
    // Display result without needing to open console
    document.getElementById('p').innerHTML+=("<br/>"+arr[i+total]);
}

<p id="p">Result: </p>

Answer 10

To enhance your code, consider implementing a new function called isItGood:

var myArray = ['a', 'x', 'b', 'x', 'x', 'p', 'y', 'x', 'x', 'b', 'x', 'x'];
var arrLength = myArray.length;
for (var i = 0; i < arrLength; i++) {
    isItGood(myArray, i, 'x', 2);
};

function isItGood(arr, i, elem, total) {
    for ( var j = 0 ; j < total ; j++ ) {
        if ( i + total >= arr.length || arr[i+j] != elem ) {
            return;
        }
    }
    console.log(arr[i+total]);
    // Display result without needing to open console
    document.getElementById('p').innerHTML+=("<br/>"+arr[i+total]);
}

<p id="p">Result: </p>

Answer 11

Answer №6

Converting this code from JavaScript to Scala would make it more concise, fitting into just a single line.

myArray.sliding(3).filter(l => l(0) == 'x' && l(1) == 'x').map(l => l(2))

If I wanted to achieve the same result in JavaScript without using the built-in sliding function, I could create my own implementation. For example:

function sliding(array, n, step) {
  if(!step) step = 1;
  var r = [];
  for(var i = 0; i < array.length - n + 1; i += step) {
    r.push(array.slice(i, i + n));
  }
  return r;
}
var result = sliding(myArray, 3).filter(l => l[0] === "x" && l[1] === "x").map(l => l[2]);

The drawback of this approach is that it may run slower compared to a more iterative method. However, the performance impact is usually only noticeable with very large arrays.

Answer 12

Converting this code from JavaScript to Scala would make it more concise, fitting into just a single line.

myArray.sliding(3).filter(l => l(0) == 'x' && l(1) == 'x').map(l => l(2))

If I wanted to achieve the same result in JavaScript without using the built-in sliding function, I could create my own implementation. For example:

function sliding(array, n, step) {
  if(!step) step = 1;
  var r = [];
  for(var i = 0; i < array.length - n + 1; i += step) {
    r.push(array.slice(i, i + n));
  }
  return r;
}
var result = sliding(myArray, 3).filter(l => l[0] === "x" && l[1] === "x").map(l => l[2]);

The drawback of this approach is that it may run slower compared to a more iterative method. However, the performance impact is usually only noticeable with very large arrays.

Answer 13

Answer №7

Consider implementing a for loop that utilizes variables to access the previous index, current index, and next index of an array

var myArray = ["a", "x", "b", "x", "x", "p", "y", "x", "x", "b", "x", "x"];

for (var result = [], currentIdx = 0, prevIdx = currentIdx - 1, nextIdx = currentIdx + 1
    ; currentIdx < myArray.length - 1; currentIdx++, prevIdx++, nextIdx++) {
  if (myArray[currentIdx] === myArray[prevIdx]) result.push(myArray[nextIdx]);
};

console.log(result);
document.body.textContent = result;

Answer 14

Consider implementing a for loop that utilizes variables to access the previous index, current index, and next index of an array

var myArray = ["a", "x", "b", "x", "x", "p", "y", "x", "x", "b", "x", "x"];

for (var result = [], currentIdx = 0, prevIdx = currentIdx - 1, nextIdx = currentIdx + 1
    ; currentIdx < myArray.length - 1; currentIdx++, prevIdx++, nextIdx++) {
  if (myArray[currentIdx] === myArray[prevIdx]) result.push(myArray[nextIdx]);
};

console.log(result);
document.body.textContent = result;

Retrieving JavaScript array elements following the repeated appearance of a specific element

Answer №1

Answer №2

Answer №3

Answer №4

Answer №5

Answer №6

Answer №7

Similar questions

Create a layout with two rows of two buttons in HTML aligned to the right side while maintaining the left side's

Using a function to send multiple child data in Firebase

Angular's isteven-multi-select Component: A Versatile Selection Tool

Tips for preventing JavaScript errors when making cross-domain requests using AJAX

What is the best way to retrieve an array element from outside a function?

Wait until the npm.load callback is returned before returning module.exports

In MongoDB, rather than storing hashed passwords, it stores a "Promise" object

Connect parent-child models with checkboxes

Location of chat icon in Dialogflow messenger

Issue with Jquery - navigation menu scrolling

Kernighan and Ritchie's 2nd Edition, Illustration 1.9: Working with Character

Local variables in AngularJS across multiple Angular applications

Adding elements to a JSON array in Javascript

How do I retrieve the id of an event using a class descriptor within a JQuery Dialog constructor in Javascript?

Adding a new column to a PySpark dataframe array

Improving the Sum of Pairs solution on Codewars

Retrieve the updated text content from a textarea using JavaScript/jQuery

Showing a heading based on a value in Angular: A Complete Guide

Import MDX metadata in Next.js on the fly

Safari and iOS users may not experience the onended() event triggering