Tasks Details
easy
1.
Brackets
Determine whether a given string of parentheses (multiple types) is properly nested.
Task Score
100%
Correctness
100%
Performance
100%
A string S consisting of N characters is considered to be properly nested if any of the following conditions is true:
- S is empty;
- S has the form "(U)" or "[U]" or "{U}" where U is a properly nested string;
- S has the form "VW" where V and W are properly nested strings.
For example, the string "{[()()]}" is properly nested but "([)()]" is not.
Write a function:
class Solution { public int solution(String S); }
that, given a string S consisting of N characters, returns 1 if S is properly nested and 0 otherwise.
For example, given S = "{[()()]}", the function should return 1 and given S = "([)()]", the function should return 0, as explained above.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [0..200,000];
- string S is made only of the following characters: '(', '{', '[', ']', '}' and/or ')'.
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 24 minutes
Notes
not defined yet
Code: 10:44:54 UTC,
java,
autosave
Code: 11:07:55 UTC,
java,
autosave
// 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 {
public int solution(String S) {
Stack<Character> stack = new Stack<>();
if (S.length() == 0) {
return 1;
}
for (int i=0; i<S.length(); i++) {
if (S.charAt(i) == '(' || S.charAt(i) == '{' || S.charAt(i) == '[') {
stack.push(S.charAt(i));
} else {
if (stack.isEmpty()) {
return 0;
}
char preChar = stack.pop();
if (S.charAt(i) == ')' && preChar != '(') {
return 0;
}
if (S.charAt(i) == '}' && preChar != '{') {
return 0;
}
if (S.charAt(i) == ']' && preChar != '[') {
return 0;
}
}
}
if (!stack.isEmpty()) {
return 0;
}
return 1;
}
}
Code: 11:08:01 UTC,
java,
verify,
result: Passed
// you can also use imports, for example:
// import java.util.*;
import java.util.Stack;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String S) {
Stack<Character> stack = new Stack<>();
if (S.length() == 0) {
return 1;
}
for (int i=0; i<S.length(); i++) {
if (S.charAt(i) == '(' || S.charAt(i) == '{' || S.charAt(i) == '[') {
stack.push(S.charAt(i));
} else {
if (stack.isEmpty()) {
return 0;
}
char preChar = stack.pop();
if (S.charAt(i) == ')' && preChar != '(') {
return 0;
}
if (S.charAt(i) == '}' && preChar != '{') {
return 0;
}
if (S.charAt(i) == ']' && preChar != '[') {
return 0;
}
}
}
if (!stack.isEmpty()) {
return 0;
}
return 1;
}
}
Analysis
Code: 11:08:06 UTC,
java,
final,
score:
100
// you can also use imports, for example:
// import java.util.*;
import java.util.Stack;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
class Solution {
public int solution(String S) {
Stack<Character> stack = new Stack<>();
if (S.length() == 0) {
return 1;
}
for (int i=0; i<S.length(); i++) {
if (S.charAt(i) == '(' || S.charAt(i) == '{' || S.charAt(i) == '[') {
stack.push(S.charAt(i));
} else {
if (stack.isEmpty()) {
return 0;
}
char preChar = stack.pop();
if (S.charAt(i) == ')' && preChar != '(') {
return 0;
}
if (S.charAt(i) == '}' && preChar != '{') {
return 0;
}
if (S.charAt(i) == ']' && preChar != '[') {
return 0;
}
}
}
if (!stack.isEmpty()) {
return 0;
}
return 1;
}
}
Analysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(N)
expand all
Correctness tests
1.
0.004 s
OK
2.
0.008 s
OK
3.
0.004 s
OK
4.
0.008 s
OK
5.
0.004 s
OK
1.
0.004 s
OK
1.
0.004 s
OK
2.
0.004 s
OK
3.
0.004 s
OK
4.
0.004 s
OK
5.
0.008 s
OK
expand all
Performance tests
1.
0.296 s
OK
2.
0.008 s
OK
3.
0.024 s
OK
1.
0.036 s
OK
2.
0.004 s
OK
3.
0.008 s
OK
1.
0.264 s
OK
multiple_full_binary_trees
sequence of full trees of the form T=(TT), depths [1..10..1], with/without some brackets at the end, length=49K+
sequence of full trees of the form T=(TT), depths [1..10..1], with/without some brackets at the end, length=49K+
✔
OK
1.
0.076 s
OK
2.
0.076 s
OK
3.
0.076 s
OK
4.
0.084 s
OK
5.
0.028 s
OK
broad_tree_with_deep_paths
string of the form [TTT...T] of 300 T's, each T being '{{{...}}}' nested 200-fold, length=120K+
string of the form [TTT...T] of 300 T's, each T being '{{{...}}}' nested 200-fold, length=120K+
✔
OK
1.
0.184 s
OK
2.
0.184 s
OK