Is there a smart way to find out if there are at least two values greater than 0 in an array and return true? And false in the opposite case?
(hypothetical and wrong example using some):
const a = [9, 1, 0];
const b = [0, 0, 0];
const c = [5, 0, 0];
const cond = (el) => el > 0 && somethingElseMaybe;
console.log(a.some(cond)); // print true
console.log(b.some(cond)); // print false
console.log(c.some(cond)); // print false
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
To avoid wasted effort, you should stop the checking as soon as the condition is met. I think this meets your requirement.
function twoGreaterThanZero(arr) {
let counter = 0
for(let x of arr) {
if(x > 0 && (++counter > 1)) return true
}
return false
}
const a = [9, 1, 0]
const b = [0, 0, 0]
const c = [5, 0, 0]
console.log(twoGreaterThanZero(a)) // print true
console.log(twoGreaterThanZero(b)) // print false
console.log(twoGreaterThanZero(c)) // print 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)); // falseOne 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
