HackerRank/Java/DataStructures/Stack/src/Solution.java at master · giokeyboard/HackerRank · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
importjava.util.Scanner;
importjava.util.Stack;

publicclassSolution {
privatestaticfinalStack<Character> stack = newStack<>();
privatestaticfinalchar[][] TOKENS = newchar[][]{{'(', ')'}, {'[', ']'}, {'{', '}'}};

publicstaticvoidmain(String[] args) {
try (Scannersc = newScanner(System.in)) {
while (sc.hasNext()) {
stack.clear();
System.out.println(isBalanced(sc.next()));
 }
 }
 }

privatestaticbooleanisBalanced(Strings) {
for (charc : s.toCharArray()) {
if (isOpenTerm(c)) stack.push(c);
else {
if (stack.isEmpty() || !isMatching(stack.pop(), c)) returnfalse;
 }
 }
returnstack.isEmpty();
 }

privatestaticbooleanisMatching(charopenToken, charcloseToken) {
for (char[] arr : TOKENS) {
if (openToken == arr[0]) returncloseToken == arr[1];
 }
returnfalse;
 }

privatestaticbooleanisOpenTerm(charc) {
for (char[] arr : TOKENS) {
if (c == arr[0]) returntrue;
 }
returnfalse;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
importjava.util.Scanner;
importjava.util.Stack;

publicclassSolution {
privatestaticfinalStack<Character> stack = newStack<>();
privatestaticfinalchar[][] TOKENS = newchar[][]{{'(', ')'}, {'[', ']'}, {'{', '}'}};

publicstaticvoidmain(String[] args) {
try (Scannersc = newScanner(System.in)) {
while (sc.hasNext()) {
stack.clear();
System.out.println(isBalanced(sc.next()));
 }
 }
 }

privatestaticbooleanisBalanced(Strings) {
for (charc : s.toCharArray()) {
if (isOpenTerm(c)) stack.push(c);
else {
if (stack.isEmpty() || !isMatching(stack.pop(), c)) returnfalse;
 }
 }
returnstack.isEmpty();
 }

privatestaticbooleanisMatching(charopenToken, charcloseToken) {
for (char[] arr : TOKENS) {
if (openToken == arr[0]) returncloseToken == arr[1];
 }
returnfalse;
 }

privatestaticbooleanisOpenTerm(charc) {
for (char[] arr : TOKENS) {
if (c == arr[0]) returntrue;
 }
returnfalse;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
importjava.util.Scanner;
importjava.util.Stack;

publicclassSolution {
privatestaticfinalStack<Character> stack = newStack<>();
privatestaticfinalchar[][] TOKENS = newchar[][]{{'(', ')'}, {'[', ']'}, {'{', '}'}};

publicstaticvoidmain(String[] args) {
try (Scannersc = newScanner(System.in)) {
while (sc.hasNext()) {
stack.clear();
System.out.println(isBalanced(sc.next()));
 }
 }
 }

privatestaticbooleanisBalanced(Strings) {
for (charc : s.toCharArray()) {
if (isOpenTerm(c)) stack.push(c);
else {
if (stack.isEmpty() || !isMatching(stack.pop(), c)) returnfalse;
 }
 }
returnstack.isEmpty();
 }

privatestaticbooleanisMatching(charopenToken, charcloseToken) {
for (char[] arr : TOKENS) {
if (openToken == arr[0]) returncloseToken == arr[1];
 }
returnfalse;
 }

privatestaticbooleanisOpenTerm(charc) {
for (char[] arr : TOKENS) {
if (c == arr[0]) returntrue;
 }
returnfalse;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
importjava.util.Scanner;
importjava.util.Stack;

publicclassSolution {
privatestaticfinalStack<Character> stack = newStack<>();
privatestaticfinalchar[][] TOKENS = newchar[][]{{'(', ')'}, {'[', ']'}, {'{', '}'}};

publicstaticvoidmain(String[] args) {
try (Scannersc = newScanner(System.in)) {
while (sc.hasNext()) {
stack.clear();
System.out.println(isBalanced(sc.next()));
 }
 }
 }

privatestaticbooleanisBalanced(Strings) {
for (charc : s.toCharArray()) {
if (isOpenTerm(c)) stack.push(c);
else {
if (stack.isEmpty() || !isMatching(stack.pop(), c)) returnfalse;
 }
 }
returnstack.isEmpty();
 }

privatestaticbooleanisMatching(charopenToken, charcloseToken) {
for (char[] arr : TOKENS) {
if (openToken == arr[0]) returncloseToken == arr[1];
 }
returnfalse;
 }

privatestaticbooleanisOpenTerm(charc) {
for (char[] arr : TOKENS) {
if (c == arr[0]) returntrue;
 }
returnfalse;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
importjava.util.Scanner;
importjava.util.Stack;

publicclassSolution {
privatestaticfinalStack<Character> stack = newStack<>();
privatestaticfinalchar[][] TOKENS = newchar[][]{{'(', ')'}, {'[', ']'}, {'{', '}'}};

publicstaticvoidmain(String[] args) {
try (Scannersc = newScanner(System.in)) {
while (sc.hasNext()) {
stack.clear();
System.out.println(isBalanced(sc.next()));
 }
 }
 }

privatestaticbooleanisBalanced(Strings) {
for (charc : s.toCharArray()) {
if (isOpenTerm(c)) stack.push(c);
else {
if (stack.isEmpty() || !isMatching(stack.pop(), c)) returnfalse;
 }
 }
returnstack.isEmpty();
 }

privatestaticbooleanisMatching(charopenToken, charcloseToken) {
for (char[] arr : TOKENS) {
if (openToken == arr[0]) returncloseToken == arr[1];
 }
returnfalse;
 }

privatestaticbooleanisOpenTerm(charc) {
for (char[] arr : TOKENS) {
if (c == arr[0]) returntrue;
 }
returnfalse;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
importjava.util.Scanner;
importjava.util.Stack;

publicclassSolution {
privatestaticfinalStack<Character> stack = newStack<>();
privatestaticfinalchar[][] TOKENS = newchar[][]{{'(', ')'}, {'[', ']'}, {'{', '}'}};

publicstaticvoidmain(String[] args) {
try (Scannersc = newScanner(System.in)) {
while (sc.hasNext()) {
stack.clear();
System.out.println(isBalanced(sc.next()));
 }
 }
 }

privatestaticbooleanisBalanced(Strings) {
for (charc : s.toCharArray()) {
if (isOpenTerm(c)) stack.push(c);
else {
if (stack.isEmpty() || !isMatching(stack.pop(), c)) returnfalse;
 }
 }
returnstack.isEmpty();
 }

privatestaticbooleanisMatching(charopenToken, charcloseToken) {
for (char[] arr : TOKENS) {
if (openToken == arr[0]) returncloseToken == arr[1];
 }
returnfalse;
 }

privatestaticbooleanisOpenTerm(charc) {
for (char[] arr : TOKENS) {
if (c == arr[0]) returntrue;
 }
returnfalse;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
importjava.util.Scanner;
importjava.util.Stack;

publicclassSolution {
privatestaticfinalStack<Character> stack = newStack<>();
privatestaticfinalchar[][] TOKENS = newchar[][]{{'(', ')'}, {'[', ']'}, {'{', '}'}};

publicstaticvoidmain(String[] args) {
try (Scannersc = newScanner(System.in)) {
while (sc.hasNext()) {
stack.clear();
System.out.println(isBalanced(sc.next()));
 }
 }
 }

privatestaticbooleanisBalanced(Strings) {
for (charc : s.toCharArray()) {
if (isOpenTerm(c)) stack.push(c);
else {
if (stack.isEmpty() || !isMatching(stack.pop(), c)) returnfalse;
 }
 }
returnstack.isEmpty();
 }

privatestaticbooleanisMatching(charopenToken, charcloseToken) {
for (char[] arr : TOKENS) {
if (openToken == arr[0]) returncloseToken == arr[1];
 }
returnfalse;
 }

privatestaticbooleanisOpenTerm(charc) {
for (char[] arr : TOKENS) {
if (c == arr[0]) returntrue;
 }
returnfalse;
 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
importjava.util.Scanner;
importjava.util.Stack;

publicclassSolution {
privatestaticfinalStack<Character> stack = newStack<>();
privatestaticfinalchar[][] TOKENS = newchar[][]{{'(', ')'}, {'[', ']'}, {'{', '}'}};

publicstaticvoidmain(String[] args) {
try (Scannersc = newScanner(System.in)) {
while (sc.hasNext()) {
stack.clear();
System.out.println(isBalanced(sc.next()));
 }
 }
 }

privatestaticbooleanisBalanced(Strings) {
for (charc : s.toCharArray()) {
if (isOpenTerm(c)) stack.push(c);
else {
if (stack.isEmpty() || !isMatching(stack.pop(), c)) returnfalse;
 }
 }
returnstack.isEmpty();
 }

privatestaticbooleanisMatching(charopenToken, charcloseToken) {
for (char[] arr : TOKENS) {
if (openToken == arr[0]) returncloseToken == arr[1];
 }
returnfalse;
 }

privatestaticbooleanisOpenTerm(charc) {
for (char[] arr : TOKENS) {
if (c == arr[0]) returntrue;
 }
returnfalse;
 }
}