Tasks Details
medium
Compute the number of "True" values in an OR-Pascal-triangle structure.
Task Score
100%
Correctness
100%
Performance
100%
On the sequence of logical values (true or false) we can build up an OR-Pascal-triangle structure. Instead of summing the values, as in a standard Pascal-triangle, we will combine them using the OR function. That means that the lowest row is simply the input sequence, and every entry in each subsequent row is the OR of the two elements below it. For example, the OR-Pascal-triangle built on the array [true, false, false, true, false] is as follows:
Your job is to count the number of nodes in the OR-Pascal-triangle that contain the value true (this number is 11 for the animation above).
Write a function:
class Solution { public int solution(boolean[] P); }
that, given an array P of N Booleans, returns the number of fields in the OR-Pascal-triangle built on P that contain the value true. If the result is greater than 1,000,000,000, your function should return 1,000,000,000.
Given P = [true, false, false, true, false], the function should return 11, as explained above.
Given P = [true, false, false, true], the function should return 7, as can be seen in the animation below.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000].
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Java 21
Time spent on task 1 minutes
Notes
not defined yet
Code: 09:03:42 UTC,
java,
autosave
Code: 09:03:50 UTC,
java,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
// you can also use imports, for example:
// import java.util.*;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
static Map<Integer, Double> sumMemo = new HashMap<>();
public static Double sumFromNodeCount(int nodeCount) {
Double sum = sumMemo.get(nodeCount);
if (sum == null) {
sum = 0d;
for (int i = 0; i <= nodeCount; i++) {
sum += i;
}
sumMemo.put(nodeCount, sum);
}
return sum;
}
public static int solution(boolean[] P) {
Double sumNode = sumFromNodeCount(P.length);
Double sumFalseNode = 0d;
boolean isFasle = false;
int contiguosFalse = 0;
for (int i = 0; i < P.length; i++) {
if (P[i] == true) {
if (isFasle == false) {
} else {
sumFalseNode += sumFromNodeCount(contiguosFalse);
contiguosFalse = 0;
}
} else {
if (isFasle == false) {
isFasle = true;
contiguosFalse++;
} else {
contiguosFalse++;
}
}
}
if (isFasle) {
sumFalseNode += sumFromNodeCount(contiguosFalse);
}
int result = (int) (sumNode - sumFalseNode);
return result > 1000000000 ? 1000000000 : result;
}
public static void main(String[] args) {
// 11
System.out.println(solution(new boolean[] { true, false, false, true, false }));
// 7
System.out.println(solution(new boolean[] { true, false, false, true }));
}
}
Code: 09:04:06 UTC,
java,
verify,
result: Passed
// you can also use imports, for example:
// import java.util.*;
import java.util.HashMap;
import java.util.Map;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
Map<Integer, Double> sumMemo = new HashMap<>();
public Double sumFromNodeCount(int nodeCount) {
Double sum = sumMemo.get(nodeCount);
if (sum == null) {
sum = 0d;
for (int i = 0; i <= nodeCount; i++) {
sum += i;
}
sumMemo.put(nodeCount, sum);
}
return sum;
}
public int solution(boolean[] P) {
Double sumNode = sumFromNodeCount(P.length);
Double sumFalseNode = 0d;
boolean isFasle = false;
int contiguosFalse = 0;
for (int i = 0; i < P.length; i++) {
if (P[i] == true) {
if (isFasle == false) {
} else {
sumFalseNode += sumFromNodeCount(contiguosFalse);
contiguosFalse = 0;
}
} else {
if (isFasle == false) {
isFasle = true;
contiguosFalse++;
} else {
contiguosFalse++;
}
}
}
if (isFasle) {
sumFalseNode += sumFromNodeCount(contiguosFalse);
}
int result = (int) (sumNode - sumFalseNode);
return result > 1000000000 ? 1000000000 : result;
}
}
Analysis
Code: 09:04:11 UTC,
java,
verify,
result: Passed
// you can also use imports, for example:
// import java.util.*;
import java.util.HashMap;
import java.util.Map;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
Map<Integer, Double> sumMemo = new HashMap<>();
public Double sumFromNodeCount(int nodeCount) {
Double sum = sumMemo.get(nodeCount);
if (sum == null) {
sum = 0d;
for (int i = 0; i <= nodeCount; i++) {
sum += i;
}
sumMemo.put(nodeCount, sum);
}
return sum;
}
public int solution(boolean[] P) {
Double sumNode = sumFromNodeCount(P.length);
Double sumFalseNode = 0d;
boolean isFasle = false;
int contiguosFalse = 0;
for (int i = 0; i < P.length; i++) {
if (P[i] == true) {
if (isFasle == false) {
} else {
sumFalseNode += sumFromNodeCount(contiguosFalse);
contiguosFalse = 0;
}
} else {
if (isFasle == false) {
isFasle = true;
contiguosFalse++;
} else {
contiguosFalse++;
}
}
}
if (isFasle) {
sumFalseNode += sumFromNodeCount(contiguosFalse);
}
int result = (int) (sumNode - sumFalseNode);
return result > 1000000000 ? 1000000000 : result;
}
}
Analysis
Code: 09:04:16 UTC,
java,
final,
score:
100
// you can also use imports, for example:
// import java.util.*;
import java.util.HashMap;
import java.util.Map;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
Map<Integer, Double> sumMemo = new HashMap<>();
public Double sumFromNodeCount(int nodeCount) {
Double sum = sumMemo.get(nodeCount);
if (sum == null) {
sum = 0d;
for (int i = 0; i <= nodeCount; i++) {
sum += i;
}
sumMemo.put(nodeCount, sum);
}
return sum;
}
public int solution(boolean[] P) {
Double sumNode = sumFromNodeCount(P.length);
Double sumFalseNode = 0d;
boolean isFasle = false;
int contiguosFalse = 0;
for (int i = 0; i < P.length; i++) {
if (P[i] == true) {
if (isFasle == false) {
} else {
sumFalseNode += sumFromNodeCount(contiguosFalse);
contiguosFalse = 0;
}
} else {
if (isFasle == false) {
isFasle = true;
contiguosFalse++;
} else {
contiguosFalse++;
}
}
}
if (isFasle) {
sumFalseNode += sumFromNodeCount(contiguosFalse);
}
int result = (int) (sumNode - sumFalseNode);
return result > 1000000000 ? 1000000000 : result;
}
}Analysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(N)
expand all
Correctness tests
1.
0.008 s
OK
2.
0.004 s
OK
3.
0.008 s
OK
4.
0.004 s
OK
5.
0.008 s
OK
6.
0.008 s
OK
7.
0.008 s
OK
8.
0.008 s
OK
1.
0.008 s
OK
2.
0.004 s
OK
3.
0.008 s
OK
1.
0.008 s
OK
2.
0.008 s
OK
3.
0.008 s
OK
1.
0.008 s
OK
2.
0.008 s
OK
3.
0.008 s
OK
1.
0.008 s
OK
2.
0.008 s
OK
3.
0.008 s
OK
1.
0.008 s
OK
2.
0.008 s
OK
3.
0.008 s
OK
expand all
Performance tests
1.
0.100 s
OK
2.
0.120 s
OK
3.
0.140 s
OK
1.
0.132 s
OK
2.
0.160 s
OK
3.
0.220 s
OK
1.
0.092 s
OK
2.
0.088 s
OK
3.
0.108 s
OK
4.
0.112 s
OK
1.
0.200 s
OK
2.
0.256 s
OK