文字列のバランスが取れているかどうかを確認するにはどうすればよいですか？
入力文字列のバランスが取れているかどうかをテストしたいと思います。開き括弧、閉じ括弧、角かっこ、または中括弧が一致していれば、バランスが取れています。
example:
{} balanced
() balanced
[] balanced
If S is balanced so is (S)
If S and T are balanced so is ST
public static boolean isBalanced(String in)
{
Stack st = new Stack();
for(char chr : in.toCharArray())
{
if(chr == '{')
st.Push(chr);
}
return false;
}
何をすべきかを選択するのに問題があります。すべての開始または終了の括弧、ブラケット、またはブレースをスタックに入れてから、それらをポップアウトする必要がありますか？私がそれらをポップアウトした場合、それは本当に私をどのように助けますか？
1）すべての開始ブラケットに対して：{ [ (それをスタックにプッシュします。
2）すべての閉じ括弧に対して：} ] )スタックからポップし、ブラケットのタイプが一致するかどうかを確認します。返されない場合はfalse;
つまり文字列の現在の記号は}そしてスタックからポップされた場合は{次に、すぐにfalseを返します。
3）行末とスタックが空でない場合は、falseを返し、そうでない場合はtrueを返します。
はい、スタックはタスクに適した選択です。または、再帰関数を使用することもできます。スタックを使用する場合は、スタックの各開始ブラケットを押すという考え方です。終了ブラケットに遭遇したら、スタックの最上部がそれに一致することを確認します。一致する場合はポップオフし、一致しない場合はエラーです。完了すると、スタックは空になります。
import Java.util.Stack;
public class Balanced {
public static boolean isBalanced(String in)
{
Stack<Character> st = new Stack<Character>();
for(char chr : in.toCharArray())
{
switch(chr) {
case '{':
case '(':
case '[':
st.Push(chr);
break;
case ']':
if(st.isEmpty() || st.pop() != '[')
return false;
break;
case ')':
if(st.isEmpty() || st.pop() != '(')
return false;
break;
case '}':
if(st.isEmpty() || st.pop() != '{')
return false;
break;
}
}
return st.isEmpty();
}
public static void main(String args[]) {
if(args.length != 0) {
if(isBalanced(args[0]))
System.out.println(args[0] + " is balanced");
else
System.out.println(args[0] + " is not balanced");
}
}
}
以下は、文字列のバランスが取れているかどうかを検出するためのJavaコードサンプルです。
http://introcs.cs.princeton.edu/Java/43stack/Parentheses.Java.html
アイデアはそれです-
- 開口部ブレースごとに
( [ {、スタックにプッシュします。 - ブレースを閉じるために
) ] }、一致する開始中括弧をポップしてみてください( [ }スタックから。一致するオープニングブレースが見つからない場合は、文字列のバランスが取れていません。 - 文字列全体を処理した後、スタックが空の場合、文字列はバランスが取れています。そうしないと、文字列のバランスが取れません。
大まかに言えば、バランスが取れていれば、スタックは空になっているはずです。
そのためには、}を解析するときにスタックをポップする必要があります
追加の要件は、}の前に{が付いているか、ポップされた文字が{であることを確認することです。
このコードは、ブラケットタイプごとに整数（またはバイト）変数のみを使用してこの問題を解決するために作成しました。
public boolean checkWithIntegers(String input) {
int brackets = 0;
for (char c: input.toCharArray()) {
switch (c) {
case '(':
brackets++;
break;
case ')':
if (brackets == 0)
return false;
brackets--;
break;
default:
break;
}
}
return brackets == 0;
}
public static void main(String... args) {
Borrar b = new Borrar();
System.out.println( b.checkWithIntegers("") );
System.out.println( b.checkWithIntegers("(") );
System.out.println( b.checkWithIntegers(")") );
System.out.println( b.checkWithIntegers(")(") );
System.out.println( b.checkWithIntegers("()") );
}
OBS
- 空の文字列はバランスが取れていると思います。これは、前のチェックだけで変更できます。
- ブラケットの例を1つだけ使用していますが、別のケーススイッチを追加するだけで他のタイプをすばやく追加できます。
この助けを願っています。乾杯！
対応するハックランクリンク： https://www.hackerrank.com/challenges/balanced-brackets/problem
import Java.util.Stack;
class BalancedParenthesis {
static String isBalanced(String s) {
return isBalanced(s.toCharArray());
}
private static String isBalanced(final char[] chars) {
final Stack<Character> stack = new Stack<>();
for (char eachChar : chars) {
if (eachChar == '{' || eachChar == '[' || eachChar == '(') {
stack.Push(eachChar);
} else {
if (stack.isEmpty()) {
return "NO";
}
if (correspondingCloseBracket(stack.peek()) != eachChar) {
return "NO";
}
stack.pop();
}
}
return stack.isEmpty() ? "YES" : "NO";
}
private static char correspondingCloseBracket(final char eachChar) {
if (eachChar == '{') {
return '}';
}
if (eachChar == '[') {
return ']';
}
return ')';
}
}
import Java.util.*;
public class Parenthesis
{
public static void main (String ...argd)
{
Scanner sc=new Scanner(System.in);
System.out.println("enetr string");
String s=sc.nextLine();
Stack<Character> st=new Stack<Character>();
for (int i=0;i<s.length();++i)
{
if((s.charAt(i)=='(')||(s.charAt(i)=='{')||(s.charAt(i)=='['))
{
st.Push(s.charAt(i));
}
else if(st.isEmpty()==false)
{
switch(s.charAt(i))
{
case']':
if(st.pop()!='[')
{
System.out.println("unbalanced");
System.exit(0);
}
break;
case'}':
if(st.pop()!='{')
{
System.out.println("unbalanced");
System.exit(0);
}
break;
case')':
if(st.pop()!='(')
{
System.out.println("unbalanced");
System.exit(0);
}
break;
}
}
}
if(st.isEmpty())
{
System.out.println("balanced paranthesis");
}
else
System.out.println("not balance");
}
}
import Java.util.Stack;
public class SyntaxChecker {
/**
* This enum represents all types of open brackets. If we have a new type then
* just add it to this list with the corresponding closed bracket in the other
* ClosedBracketTypes enum
* @author AnishBivalkar
*
*/
private enum OpenBracketTypes {
LEFT_ROUND_BRACKET('('),
LEFT_SQUARE_BRACKET('['),
LEFT_CURLY_BRACKET('{');
char ch;
// Constructs the given bracket type
OpenBracketTypes(char ch) {
this.ch = ch;
}
// Getter for the type of bracket
public final char getBracket() {
return ch;
}
/**
* This method checks if the current character is of type OpenBrackets
* @param name
* @return True if the current character is of type OpenBrackets, false otherwise
*/
public static boolean contains(final char name) {
for (OpenBracketTypes type : OpenBracketTypes.values()) {
if (type.getBracket() == name) {
return true;
}
}
return false;
}
}
/**
* This enum represents all types of Closed brackets. If we have a new type then
* just add it to this list with the corresponding open bracket in the other
* OpenBracketTypes enum
* @author AnishBivalkar
*
*/
private enum CloseBracketTypes {
RIGHT_ROUND_BRACKET(')'),
RIGHT_SQUARE_BRACKET(']'),
RIGHT_CURLY_BRACKET('}');
char ch;
CloseBracketTypes(char ch) {
this.ch = ch;
}
private char getBracket() {
return ch;
}
/**
* This method checks if a given bracket type is a closing bracket and if it correctly
* completes the opening bracket
* @param bracket
* @param brackets
* @return
*/
public static boolean isBracketMatching(char bracket, Stack<Character> brackets) {
// If the current stack is empty and we encountered a closing bracket then this is
// an incorrect syntax
if (brackets.isEmpty()) {
return false;
} else {
if (bracket == CloseBracketTypes.RIGHT_ROUND_BRACKET.getBracket()) {
if (brackets.peek() == OpenBracketTypes.LEFT_ROUND_BRACKET.getBracket()) {
return true;
}
} else if (bracket == CloseBracketTypes.RIGHT_SQUARE_BRACKET.ch) {
if (brackets.peek() == OpenBracketTypes.LEFT_SQUARE_BRACKET.getBracket()) {
return true;
}
} else if (bracket == CloseBracketTypes.RIGHT_CURLY_BRACKET.ch) {
if (brackets.peek() == OpenBracketTypes.LEFT_CURLY_BRACKET.getBracket()) {
return true;
}
}
return false;
}
}
/**
* This method checks if the current character is of type ClosedBrackets
* @param name
* @return true if the current character is of type ClosedBrackets, false otherwise
*/
public static boolean contains(final char name) {
for (CloseBracketTypes type : CloseBracketTypes.values()) {
if (type.getBracket() == name) {
return true;
}
}
return false;
}
}
/**
* This method check the syntax for brackets. There should always exist a
* corresponding closing bracket for a open bracket of same type.
*
* It runs in O(N) time with O(N) worst case space complexity for the stack
* @param sentence The string whose syntax is to be checked
* @return True if the syntax of the given string is correct, false otherwise
*/
public static boolean matchBrackets(String sentence) {
boolean bracketsMatched = true;
// Check if sentence is null
if (sentence == null) {
throw new IllegalArgumentException("Input cannot be null");
}
// Empty string has correct syntax
if (sentence.isEmpty()) {
return bracketsMatched;
} else {
Stack<Character> brackets = new Stack<Character>();
char[] letters = sentence.toCharArray();
for (char letter : letters) {
// If the letter is a type of open bracket then Push it
// in stack else if the letter is a type of closing bracket
// then pop it from the stack
if (OpenBracketTypes.contains(letter)) {
brackets.Push(letter);
} else if (CloseBracketTypes.contains(letter)) {
if (!CloseBracketTypes.isBracketMatching(letter, brackets)) {
return false;
} else {
brackets.pop();
}
}
}
// If the stack is not empty then the syntax is incorrect
if (!brackets.isEmpty()) {
bracketsMatched = false;
}
}
return bracketsMatched;
}
/**
* @param args
*/
public static void main(String[] args) {
String words = "[[][][]Anfield[[]([])[]]becons()]";
boolean isSyntaxCorrect = SyntaxChecker.matchBrackets(words);
if (isSyntaxCorrect) {
System.out.println("The syntax is correct");
} else {
System.out.println("Incorrect syntax");
}
}
}
これに関するフィードバックは大歓迎です。何かがおかしい、または役に立たない場合は、批判してください。私はただ学ぼうとしています。