Java équilibré expressions vérifier {[()]}

J'espère que ce code peut vous aider:

import java.util.Stack;
public class BalancedParenthensies {
public static void main(String args[]) {
System.out.println(balancedParenthensies("{(a,b)}"));
System.out.println(balancedParenthensies("{(a},b)"));
System.out.println(balancedParenthensies("{)(a,b}"));
}
public static boolean balancedParenthensies(String s) {
Stack<Character> stack  = new Stack<Character>();
for(int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if(c == '[' || c == '(' || c == '{' ) {     
stack.push(c);
} else if(c == ']') {
if(stack.isEmpty() || stack.pop() != '[') {
return false;
}
} else if(c == ')') {
if(stack.isEmpty() || stack.pop() != '(') {
return false;
}           
} else if(c == '}') {
if(stack.isEmpty() || stack.pop() != '{') {
return false;
}
}
}
return stack.isEmpty();
}
}

OriginalL'auteur Smartoop

Le pseudo équivalent de code java de la mise en œuvre de l'algorithme est de java est comme suit.

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
/**
* @author Yogen Rai
*/
public class BalancedBracket {
public static void main(String[] args) {
String braces = "{{}(";
if(isBalanced(braces)){
System.out.println("YES");
}else{
System.out.println("NO");
}
}
public static boolean isBalanced(String brackets) {
//set matching pairs
Map<Character, Character> braces = new HashMap<>();
braces.put('(', ')');
braces.put('[',']');
braces.put('{','}');
//if length of string is odd, then it is not balanced
if (brackets.length() % 2 != 0) {
return false;
}
//travel half until openings are found and compare with
//remaining if the closings matches
Stack<Character> halfBraces = new Stack();
for(char ch: brackets.toCharArray()) {
if (braces.containsKey(ch)) {
halfBraces.push(braces.get(ch));
}
//if stack is empty or if closing bracket is not equal to top of stack,
//then braces are not balanced
else if(halfBraces.isEmpty() || ch != halfBraces.pop()) {
return false;
}
}
return halfBraces.isEmpty();
}
}

OriginalL'auteur Yogen Rai

Avez-vous l'esprit si je vais l'ajouter à ma freaky-style solution basée sur JavaScript?

C'est un ad-hoc des trucs, pas pour la production, mais pour les entrevues, ou quelque chose comme ça. Ou juste pour le plaisir.

Le code:

function reduceStr (str) {
const newStr = str.replace('()', '').replace('{}', '').replace('[]', '')
if (newStr !== str) return reduceStr(newStr)
return newStr
}
function verifyNesting (str) {
return reduceStr(str).length === 0
}

Vérifie:

console.log(verifyNesting('[{{[(){}]}}[]{}{{(())}}]')) //correct
console.log(verifyNesting('[{{[(){}]}}[]{}{({())}}]')) //incorrect

Explication:

Il va supprimer récursivement ferme paires "()", "[]" et "{}":

'[{{[(){}]}}[]{}{{(())}}]'
'[{{}}[]{}{{(())}}]'
'[{}{}{{()}}]'
'[{}{{}}]'
'[{{}}]'
'[{}]'
'' 

Si, à la fin longueur de la chaîne est vide - il est true, si ce n'est - il false.

P. S. Quelques réponses

• Pourquoi pas pour la production?

Parce que c'est lent, et ne se soucient pas de la possibilité de certains autres caractères entre les paires.

• Pourquoi JS? Nous aimons Java

Parce que je suis un développeur frontend, mais a rencontré la même tâche, peut-être, il peut être utile pour quelqu'un. Et le JS est également JVM lang =)

• Mais pourquoi...

Parce que tous les JS développeurs sont fous, c'est pourquoi.

OriginalL'auteur Sergei Panfilov

S'il vous plaît essayer cette.

    import java.util.Stack;
public class PatternMatcher {
static String[] patterns = { "{([])}", "{}[]()", "(}{}]]", "{()", "{}" };
static String openItems = "{([";
boolean isOpen(String sy) {
return openItems.contains(sy);
}
String getOpenSymbol(String byCloseSymbol) {
switch (byCloseSymbol) {
case "}":
return "{";
case "]":
return "[";
case ")":
return "(";
default:
return null;
}
}
boolean isValid(String pattern) {
if(pattern == null) {
return false;
}
Stack<String> stack = new Stack<String>();
char[] symbols = pattern.toCharArray();
if (symbols.length == 0 || symbols.length % 2 != 0) {
return false;
}
for (char c : symbols) {
String symbol = Character.toString(c);
if (isOpen(symbol)) {
stack.push(symbol);
} else {
String openSymbol = getOpenSymbol(symbol);
if (stack.isEmpty() 
|| openSymbol == null 
|| !openSymbol.equals(stack.pop())) {
return false;
}
}
}
return stack.isEmpty();
}
public static void main(String[] args) {
PatternMatcher patternMatcher = new PatternMatcher();
for (String pattern : patterns) {
boolean valid = patternMatcher.isValid(pattern);
System.out.println(pattern + "\t" + valid);
}
}
}

OriginalL'auteur Sami

C'est ma propre mise en œuvre. J'ai essayé de faire le plus court d'une façon la plus claire possible:

public static boolean isBraceBalanced(String braces) {
Stack<Character> stack = new Stack<Character>();
for(char c : braces.toCharArray()) {
if(c == '(' || c == '[' || c == '{') {
stack.push(c);
} else if((c == ')' && (stack.isEmpty() || stack.pop() != '(')) ||
(c == ']' && (stack.isEmpty() || stack.pop() != '[')) ||
(c == '}' && (stack.isEmpty() || stack.pop() != '{'))) {
return false;
}
}
return stack.isEmpty();
}

OriginalL'auteur FerDensetsu

Ce code fonctionne pour tous les cas inclure d'autres caractères n'est pas seulement parenthèses
ex:

Veuillez entrée

{ibrahim[k]}

vrai

()[]{}[][]

vrai
saddsd]
faux

public class Solution {
private static Map<Character, Character> parenthesesMapLeft = new HashMap<>();
private static Map<Character, Character> parenthesesMapRight = new HashMap<>();
static {
parenthesesMapLeft.put('(', '(');
parenthesesMapRight.put(')', '(');
parenthesesMapLeft.put('[', '[');
parenthesesMapRight.put(']', '[');
parenthesesMapLeft.put('{', '{');
parenthesesMapRight.put('}', '{');
}
public static void main(String[] args) {
System.out.println("Please enter input");
Scanner scanner = new Scanner(System.in);
String str = scanner.nextLine();
System.out.println(isBalanced(str));
}
public static boolean isBalanced(String str) {
boolean result = false;
if (str.length() < 2)
return false;
Stack<Character> stack = new Stack<>();
for (int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
if (!parenthesesMapRight.containsKey(ch) && !parenthesesMapLeft.containsKey(ch)) {
continue;
}
if (parenthesesMapLeft.containsKey(ch)) {
stack.push(ch);
} else {
if (!stack.isEmpty() && stack.pop() == parenthesesMapRight.get(ch).charValue()) {
result = true;
} else {
return false;
}
}
}
if (!stack.isEmpty())
return result = false;
return result;
}
}

OriginalL'auteur ikarayel

import java.util.Stack;
public class StackParenthesisImplementation {
public static void main(String[] args) {
String Parenthesis = "[({})]";
char[] charParenthesis  = Parenthesis.toCharArray();
boolean evalParanthesisValue = evalParanthesis(charParenthesis);
if(evalParanthesisValue == true)
System.out.println("Brackets are good");
else
System.out.println("Brackets are not good");
}
static boolean evalParanthesis(char[] brackets)
{       
boolean IsBracesOk = false;
boolean PairCount = false;
Stack<Character> stack = new Stack<Character>();
for(char brace : brackets)
{                       
if(brace == '(' || brace == '{' || brace == '['){
stack.push(brace);  
PairCount = false;
}
else if(!stack.isEmpty())
{
if(brace == ')' || brace == '}' || brace == ']')
{
char CharPop = stack.pop();
if((brace == ')' && CharPop == '('))
{
IsBracesOk = true; PairCount = true;
}
else if((brace == '}') && (CharPop == '{'))
{
IsBracesOk = true; PairCount = true;
}
else if((brace == ']') && (CharPop == '['))
{
IsBracesOk = true; PairCount = true;
}
else 
{
IsBracesOk = false;
PairCount = false;
break;
}
}   
}
}   
if(PairCount == false)
return IsBracesOk = false;
else
return IsBracesOk = true;
}
}

OriginalL'auteur Nik

Comment à ce sujet, il utilise à la fois le concept de pile, plus les chèques de guichet:

import java.util.*;
class Solution{
public static void main(String []argh)
{
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String input=sc.next();
Stack<Character> stk = new Stack<Character>();
char[] chr = input.toCharArray();
int ctrl = 0, ctrr = 0;
if(input.length()==0){
System.out.println("true");
}
for(int i=0; i<input.length(); i++){
if(chr[i]=='{'||chr[i]=='('||chr[i]=='['){
ctrl++;
stk.push(chr[i]);
//System.out.println(stk);
}
}
for(int i=0; i<input.length(); i++){
if(chr[i]=='}'||chr[i]==')'||chr[i]==']'){
ctrr++;
if(!stk.isEmpty())
stk.pop();
//System.out.println(stk);
}
}
//System.out.println(stk);
if(stk.isEmpty()&&ctrl==ctrr)
System.out.println("true");
else
System.out.println("false");
}
}
}

OriginalL'auteur palslav

S'il vous plaît essayer ce que j'ai vérifié. Il fonctionne correctement

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
public class CloseBrackets {
private static Map<Character, Character> leftChar = new HashMap<>();
private static Map<Character, Character> rightChar = new HashMap<>();
static {
leftChar.put('(', '(');
rightChar.put(')', '(');
leftChar.put('[', '[');
rightChar.put(']', '[');
leftChar.put('{', '{');
rightChar.put('}', '{');
}
public static void main(String[] args) throws IOException {
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
String st = bf.readLine();
System.out.println(isBalanced(st));
}
public static boolean isBalanced(String str) {
boolean result = false;
if (str.length() < 2)
return false;
Stack<Character> stack = new Stack<>();
/* For Example I gave input 
* str = "{()[]}" 
*/
for (int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
if (!rightChar.containsKey(ch) && !leftChar.containsKey(ch)) {
continue;
}
//Left bracket only add to stack. Other wise it will goes to else case 
//For both above input how value added in stack 
//"{(" after close bracket go to else case
if (leftChar.containsKey(ch)) {
stack.push(ch);
} else {
if (!stack.isEmpty()) {
//For both input how it performs
//3rd character is close bracket so it will pop . pop value is "(" and map value for ")" key will "(" . So both are same . 
//it will return true. 
//now stack will contain only "{" , and travers to next up to end.
if (stack.pop() == rightChar.get(ch).charValue() || stack.isEmpty()) {
result = true;
} else {
return false;
}
} else {
return false;
}
}
}
if (!stack.isEmpty())
return result = false;
return result;
}
}

OriginalL'auteur Vaithiyanadhan Vellaichamy

L'aide d'un noeud de référence nous permet de vérifier facilement

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class CloseBracketsBalance {
private static final Map<String, String> closeBracket= new HashMap<>();
private static final List<String> allBrac = new ArrayList<>();
static {
allBrac.add("[");
allBrac.add("]");
allBrac.add("{");
allBrac.add("}");
allBrac.add("(");
allBrac.add(")");
closeBracket.put("]", "[");
closeBracket.put("}", "{");
closeBracket.put(")", "(");
}
public static void main(String[] args) {
System.out.println(checkSheetIsbalance("[{}({[]{}(dsfd)})]")); //return true
System.out.println(checkSheetIsbalance("[{}({[]{}(dsfd}))]")); //return false
}
public static boolean checkSheetIsbalance(String c) {
char[] charArr = c.toCharArray();
Node node = null;
for(int i=0,j=charArr.length;i<j;i++) {
String ch = charArr[i]+"";
if(!allBrac.contains(ch)) {
continue;
}
if(closeBracket.containsKey(ch)) {
//node close bracket               
if(node == null) {
return false;
}
if(!(node.nodeElement).equals(closeBracket.get(ch))) {
return false;
}
node = node.parent; 
} else {
//make node for open bracket                
node = new Node(ch, node);
}
}       
if(node != null) {
return false;
}
return true;
}
}
class Node {
public String nodeElement;
public Node parent;
public Node(String el, Node p) {
this.nodeElement = el;
this.parent = p;
}
}

OriginalL'auteur Birbal Singh

package com.me.hr;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Stack;
public class Paranthesis {
public static void main(String[] argh) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String input = sc.next();
Paranthesis obj = new Paranthesis();
System.out.println(obj.isEven(input));
} //Complete the code }
sc.close();
}
boolean isEven(String token) {
HashMap<Character, Character> paranthesisMap = new HashMap<Character, Character>();
paranthesisMap.put('{', '}');
paranthesisMap.put('[', ']');
paranthesisMap.put('(', ')');
//List<Character> closingThesis = Arrays.asList('}',']',')');
char[] chars = token.toCharArray();
Stack<Character> stack = new Stack<Character>();
for (char ch : chars) {
boolean push = true;
//Not Allow closing prthese first
if (stack.isEmpty() && paranthesisMap.values().contains(ch))
return false;
//Pop Out Matching closing prthese
if (!stack.isEmpty() && paranthesisMap.values().contains(ch)) {
char peek = stack.peek();
if (paranthesisMap.get(peek).equals(ch)) {
stack.pop();
push = false;
} else {
//Otherwise not matching
return false;
}
}
if (push)
stack.push(ch);
}
if (stack.isEmpty())
return true;
return false;
}
}

OriginalL'auteur shayaan

**//balanced parentheses problem (By fabboys)**
#include <iostream>
#include <string.h>
using namespace std;
class Stack{
char *arr;
int size;
int top;
public:
Stack(int s)
{
size = s;
arr = new char[size];
top = -1;
}
bool isEmpty()
{
if(top == -1)
return true;
else
return false;
}
bool isFull()
{
if(top == size-1)
return true;
else
return false;
}
void push(char n)
{
if(isFull() == false)
{
top++;
arr[top] = n;
}
}
char pop()
{
if(isEmpty() == false)
{
char x = arr[top];
top--;
return x;
}
else
return -1;
}
char Top()
{
if(isEmpty() == false)
{
return arr[top];
}
else
return -1;
}
Stack{
delete []arr;
}
};
int main()
{
int size=0;
string LineCode;
cout<<"Enter a String : ";
cin >> LineCode;
size = LineCode.length();
Stack s1(size);
char compare;
for(int i=0;i<=size;i++)
{
if(LineCode[i]=='(' || LineCode[i] == '{' || LineCode[i] =='[')
s1.push(LineCode[i]);
else if(LineCode[i]==']')
{
if(s1.isEmpty()==false){
compare =  s1.pop();
if(compare == 91){}
else
{
cout<<" Error Founded";
return 0;}
}
else
{
cout<<" Error Founded";
return 0;
}
} else if(LineCode[i] == ')')
{
if(s1.isEmpty() == false)
{
compare = s1.pop();
if(compare == 40){}
else{
cout<<" Error Founded";
return 0;
}
}else
{
cout<<"Error Founded";
return 0;
}
}else if(LineCode[i] == '}')
{
if(s1.isEmpty() == false)
{
compare = s1.pop();
if(compare == 123){}
else{
cout<<" Error Founded";
return 0;
}
}else
{
cout<<" Error Founded";
return 0;
}
}
}
if(s1.isEmpty()==true)
{
cout<<"No Error in Program:\n";
}
else
{
cout<<" Error Founded";
}
return 0;
}

OriginalL'auteur Faizan