Convert an array containing arrays of booleans to a single array of booleans (Array<Array<boolean>> to Array<boolean>)

Question

Convert an array containing arrays of booleans to a single array of booleans (Array<Array<boolean>> to Array<boolean>)

There is an array that contains multiple arrays of booleans, all of the same length.

arrBefore = [arr1, arr2, ..., arrn];

The goal is to create a new array that consists of boolean values where each index is true if any of the corresponding indexes in the inner arrays are true. Otherwise, it should be false.

arrBefore = [[true, false, false], [false, false, false], [true, false, true], [true, false, true]];

arrAfter = reduceMyArr(arrBefore);

console.log(arrAfter);

//[true, false, true]

Instead of using for loops, the task is to achieve this using map() and reduce(). Seeking assistance as I couldn't find a suitable solution online.

update 1

To avoid confusion from previous answers, clarification is needed on comparing the inner array indexes. The resulting array should have the same length as the inner arrays, with each element being true if at least one true is found across the inner arrays at that specific index.

update 2

Additional examples provided upon request:

arrBefore = [[true],[false],[true],[false]];
arrAfter = [true];
---
arrBefore = [[true, false],[false, false], [false, true], [false, false], [true, true]];
arrAfter = [true, true];
---
arrBefore = [[true, false, false, false], [true, true, false, false]];
arrAfter = [true, true, false, false];
---
arrBefore = [[true, true, false, false, false], [false, false, false, false, true]];
arrAfter = [true, true, false, false, true];

javascript arrays typescript

Answer 1

Answer №1

If you're looking to simplify this task, consider using a Generator function. This approach involves providing an array with sub-arrays and then iterating through each sub-array to perform an OR operation on the items at the same index. Here's a brief outline of how this method would function:

start:

  iteration 1:
  mainArray = [ [a01, a02, ..., aNN], [b01, b02, ..., bNN], [c01, c02, ..., cNN] ]
                 ^^^                   ^^^                   ^^^
  pointer         |                     |                     |
  OR together:   a01        ||         b01         ||        c01                   --> result01

  iteration 2:
  mainArray = [ [a01, a02, ..., aNN], [b01, b02, ..., bNN], [c01, c02, ..., cNN] ]
                      ^^^                   ^^^                   ^^^
  pointer              |                     |                     |
  OR together:        a02        ||         b02         ||        c02              --> result02

  ...

  iteration NN:
  mainArray = [ [a01, a02, ..., aNN], [b01, b02, ..., bNN], [c01, c02, ..., cNN] ]
                                ^^^                   ^^^                   ^^^
  pointer                        |                     |                     |
  OR together:                  aNN        ||         bNN         ||        cNN    --> resultNN

end

To execute this algorithm and retrieve an array from each iteration, you can utilize Array.from. Thus, you will obtain

[result01, result02, ..., resultNN]

as output.

Below is an implementation example:

function* sequentialOR(mainArray) {
  const iterators = mainArray.map(subArray => subArray[Symbol.iterator]());
  
  let allResults = iterators.map(it => it.next());
  
  while(allResults[0].done === false) {
    yield allResults
      .map(({value}) => value)
      .some(Boolean);
      
    allResults = iterators.map(it => it.next());
  } 
}

const input1 = [[true],[false],[true],[false]];
test(input1);

const input2 = [[true, false],[false, false], [false, true], [false, false], [true, true]];
test(input2);

const input3 = [[true, false, false, false], [true, true, false, false]];
test(input3);

const input4 = [[true, true, false, false, false], [false, false, false, false, true]];
test(input4);

function test(input){
  const output = Array.from(sequentialOR(input));

  console.log(
  `Input: ${JSON.stringify(input)}
Output: ${JSON.stringify(output)}`
  );
}

I've opted for Array#some in this context due to its expressiveness in implementing the OR logic. While Array#reduce can achieve similar results, using some simplifies understanding the OR operation:

arrayOfBooleans.reduce((a, b) => a || b, false)

The initial value being false represents the neutral element for OR operations. The use of reduce might be slightly less apparent compared to .some, but both methods are valid for deriving boolean outcomes.

This methodology can be generalized further by allowing different operations on each set of results. By providing a callback function, other operations can be executed easily. For instance:

const sequentialAND = sequentialOperation(arr => arr.every(Boolean));
const sequentialAdd = sequentialOperation(arr => arr.reduce((a, b) => a + b, 0));
const sequentialMax = sequentialOperation(arr => arr.reduce((a, b) => Math.max(a, b), -Infinity));
//and more variations

Answer 2

If you're looking to simplify this task, consider using a Generator function. This approach involves providing an array with sub-arrays and then iterating through each sub-array to perform an OR operation on the items at the same index. Here's a brief outline of how this method would function:

start:

  iteration 1:
  mainArray = [ [a01, a02, ..., aNN], [b01, b02, ..., bNN], [c01, c02, ..., cNN] ]
                 ^^^                   ^^^                   ^^^
  pointer         |                     |                     |
  OR together:   a01        ||         b01         ||        c01                   --> result01

  iteration 2:
  mainArray = [ [a01, a02, ..., aNN], [b01, b02, ..., bNN], [c01, c02, ..., cNN] ]
                      ^^^                   ^^^                   ^^^
  pointer              |                     |                     |
  OR together:        a02        ||         b02         ||        c02              --> result02

  ...

  iteration NN:
  mainArray = [ [a01, a02, ..., aNN], [b01, b02, ..., bNN], [c01, c02, ..., cNN] ]
                                ^^^                   ^^^                   ^^^
  pointer                        |                     |                     |
  OR together:                  aNN        ||         bNN         ||        cNN    --> resultNN

end

To execute this algorithm and retrieve an array from each iteration, you can utilize Array.from. Thus, you will obtain

[result01, result02, ..., resultNN]

as output.

Below is an implementation example:

function* sequentialOR(mainArray) {
  const iterators = mainArray.map(subArray => subArray[Symbol.iterator]());
  
  let allResults = iterators.map(it => it.next());
  
  while(allResults[0].done === false) {
    yield allResults
      .map(({value}) => value)
      .some(Boolean);
      
    allResults = iterators.map(it => it.next());
  } 
}

const input1 = [[true],[false],[true],[false]];
test(input1);

const input2 = [[true, false],[false, false], [false, true], [false, false], [true, true]];
test(input2);

const input3 = [[true, false, false, false], [true, true, false, false]];
test(input3);

const input4 = [[true, true, false, false, false], [false, false, false, false, true]];
test(input4);

function test(input){
  const output = Array.from(sequentialOR(input));

  console.log(
  `Input: ${JSON.stringify(input)}
Output: ${JSON.stringify(output)}`
  );
}

I've opted for Array#some in this context due to its expressiveness in implementing the OR logic. While Array#reduce can achieve similar results, using some simplifies understanding the OR operation:

arrayOfBooleans.reduce((a, b) => a || b, false)

The initial value being false represents the neutral element for OR operations. The use of reduce might be slightly less apparent compared to .some, but both methods are valid for deriving boolean outcomes.

This methodology can be generalized further by allowing different operations on each set of results. By providing a callback function, other operations can be executed easily. For instance:

const sequentialAND = sequentialOperation(arr => arr.every(Boolean));
const sequentialAdd = sequentialOperation(arr => arr.reduce((a, b) => a + b, 0));
const sequentialMax = sequentialOperation(arr => arr.reduce((a, b) => Math.max(a, b), -Infinity));
//and more variations

Answer 3

Answer №2

If you're looking to condense an array of boolean values into a single boolean, the choice of binary operation matters. In this scenario, using the or operation is necessary:

arrayOfBools.reduce((res, cur) => res || cur, false)

This approach will still function correctly even if the input array, arrayOfBools, is empty (returning

false</code as the default value in such cases).</p>

<p>Now, what about reducing an array of arrays into a single flattened array? This entails "flattening" the higher-order array using the <code>reduce

method:

higherOrderArray.reduce((res, cur) => res.concat(cur), [])

This method accomplishes the task effectively.

You now have the capability to flatten your array of arrays of booleans into a single flat array of boolean values and then reduce them to a single boolean. Keep in mind that utilizing a traditional loop may be more efficient.

An alternative approach involves flattening the higher-order array by leveraging the map method. You could map the array of arrays of booleans to an array of booleans using the aforementioned or-driven reduce, followed by another application of reduce.

A functional implementation could look like this:

const mapReduce = <TSource, TTarget, TReduced>
(map: (x: TSource) => TTarget) =>
    (reduce: (res: TReduced, cur: TTarget) => TReduced) =>
        (zero: TReduced) =>
            (arr: TSource[]) : TReduced => {
return !arr || !arr.length ? zero : arr.map(map).reduce(reduce, zero)

Just a friendly reminder - it's advisable to exercise caution when implementing code like this in a production environment, unless your team is fully onboard with functional programming concepts. This example primarily serves as a learning tool.

Answer 4

If you're looking to condense an array of boolean values into a single boolean, the choice of binary operation matters. In this scenario, using the or operation is necessary:

arrayOfBools.reduce((res, cur) => res || cur, false)

This approach will still function correctly even if the input array, arrayOfBools, is empty (returning

false</code as the default value in such cases).</p>

<p>Now, what about reducing an array of arrays into a single flattened array? This entails "flattening" the higher-order array using the <code>reduce

method:

higherOrderArray.reduce((res, cur) => res.concat(cur), [])

This method accomplishes the task effectively.

You now have the capability to flatten your array of arrays of booleans into a single flat array of boolean values and then reduce them to a single boolean. Keep in mind that utilizing a traditional loop may be more efficient.

An alternative approach involves flattening the higher-order array by leveraging the map method. You could map the array of arrays of booleans to an array of booleans using the aforementioned or-driven reduce, followed by another application of reduce.

A functional implementation could look like this:

const mapReduce = <TSource, TTarget, TReduced>
(map: (x: TSource) => TTarget) =>
    (reduce: (res: TReduced, cur: TTarget) => TReduced) =>
        (zero: TReduced) =>
            (arr: TSource[]) : TReduced => {
return !arr || !arr.length ? zero : arr.map(map).reduce(reduce, zero)

Just a friendly reminder - it's advisable to exercise caution when implementing code like this in a production environment, unless your team is fully onboard with functional programming concepts. This example primarily serves as a learning tool.

Answer 5

Answer №3

const initialArr = [true, false, false],[false, false, false],[true, false, true],[true, false, true]]

let finalArr = []

initialArr.forEach((innerArr) => {
  finalArr.push(!!innerArr.find((element) => element === true))
})

console.log(finalArr)

// [true, false, true, true]

Answer 6

const initialArr = [true, false, false],[false, false, false],[true, false, true],[true, false, true]]

let finalArr = []

initialArr.forEach((innerArr) => {
  finalArr.push(!!innerArr.find((element) => element === true))
})

console.log(finalArr)

// [true, false, true, true]

Convert an array containing arrays of booleans to a single array of booleans (Array<Array<boolean>> to Array<boolean>)

Answer №1

Answer №2

Answer №3

Similar questions

What is the best way to access the phone's dialer?

JQuery Challenge: Solving Dynamic Modal Issues

Having trouble providing JSDoc annotations for a generic identity function

Encountering difficulties in storing array data into MongoDB collection

Steps for converting a JSON response into a .json file.Steps to transform a

ajax memory leakage

Using TypeScript to pass an array list as a parameter in the HTTP native GET method

Using Angular route resolve to handle the sessionStorage login status

Can express-handlebars tags be utilized within an HTML script tag when on the client side?

Leveraging the div element for redirecting to a PHP script

Exploring the integration of query parameters in Postman using mongoose

React's connect method is causing issues with my test case

When evaluating objects or arrays of objects to determine modifications

What is the process for integrating Android Java code with Node.js code?

Attempting to execute this function to verify the presence of matching email addresses within the database

Discover automatically generated titles for dynamic hyperlinks

How do I combine Dj3 rotation?

Using Excel VBA to transfer a 2D array to a different worksheet

Setting 2D string arrays with char pointers

Directive in AngularJS fails to trigger upon form reset