Check if at least two elements in an array are greater than zero - JavaScript/Typescript [duplicate]

Use filter() to remove values below zero and then check if the length of resulting array is greater than or equal to two

const twoGreaterThanZero = arr => arr.filter(x => x > 0).length >= 2;

console.log(twoGreaterThanZero([9, 1, 0])) //true
console.log(twoGreaterThanZero([0, 0, 0])) //false
console.log(twoGreaterThanZero([5, 0, 0])) //false

If you don't want to iterate over the entire array you can use a loop and break out of it early once your condition is satisfied. I think the answer that uses filter is more elegant, but if you're list is insanely large you might see a benefit from not iterating the entire thing.

I broke this function into it's basic parts and created a curried version.

The question is "are there 2 or more values greater than 0 in the array". But it can be boiled down to "are there X or more values that pass comparator"?

const a = [9, 1, 0];
const b = [0, 0, 0];
const c = [5, 0, 0];

const quantityCompare = compare => quantity => arr => {
  let count = 0;
  for (let i = 0; i < arr.length; i += 1) {
    if (compare(arr[i])) count += 1;
    if (count >= quantity) return true;
  }
  return false;
};

const twoElementsGreaterThanZero = quantityCompare(x => x > 0)(2);

console.log(twoElementsGreaterThanZero(a)); // true
console.log(twoElementsGreaterThanZero(b)); // false
console.log(twoElementsGreaterThanZero(c)); // false

One more for fun, you can use Array.some (an Array.forEach you can break out of) instead of the for loop:

const a = [9, 1, 0];
const b = [0, 0, 0];
const c = [5, 0, 0];

const quantityCompare = compare => quantity => arr => {
  let count = 0;
  return arr.some(el => {
    if (compare(el)) count += 1;
    if (count >= quantity) return true;
  })
}

const twoElementsGreaterThanZero = quantityCompare(x => x > 0)(2);

console.log(twoElementsGreaterThanZero(a)); // true
console.log(twoElementsGreaterThanZero(b)); // false
console.log(twoElementsGreaterThanZero(c)); // false

If you are in a situation where doing things like this is frequently necessary, you can always create your own facility for producing predicate functions. In this case, you could start with a master function to create functions that return true or false if an array contains a minimum number of values that satisfy a condition:

function minimumSatisfy(condition, minimum) {
  return function(array) {
    for (var i = 0, c = 0; i < array.length && c < minimum; i++) {
      if (condition(array[i]))
        c++;
    }
    return c >= minimum;
  }
}

To use that for checking your particular case, use it to make a specific function:

let twoGtZero = minimumSatisfy(v => v > 0, 2);

Now you can test any array with that predicate:

if (twoGtZero(someArray)) {
  // ...
}

Of course if you've only got one place in your code that requires such a test, it would be silly to do this.

Try that

var a = [9, 1, 0]
var b = [0, 0, 0]
var c = [5, 0, 0]

function atLeastTwoEntries(arr, entrie) {
  return arr.indexOf(entrie) !== arr.lastIndexOf(entrie)
}

console.log(atLeastTwoEntries(a, 0))
console.log(atLeastTwoEntries(b, 0))
console.log(atLeastTwoEntries(c, 0))

Try this,

console.log(a.filter(s => s > 0).length >= 2); // print true
console.log(b.filter(s => s > 0).length >= 2); // print false
console.log(c.filter(s => s > 0).length >= 2); // print false