WellBalanced - Cadenas balanceadas en Java y Haskell

A continuación resuelvo un ejercicio sencillo tanto en Java como en Haskell en el que se utiliza una pila o stack. Este nos pide que escribamos una función qu permita determinar si una cadena de caracteres está bien balanceada o equilibrada en lo que se refiere a los paréntesis, corchetes y llaves que contiene. El resto de caracteres no interesan. Por ejemplo la cadena "v(hg(jij)hags{ss[dd]dd})" está balanceada pero no así la cadena "ff(h([sds)sds]ss)hags". Para ello se utilizará una pila en la que cada vez que aparezca un signo de apertura, se introduce en la pila y cada vez que aparece un signo de cierre se extrae la cima de la pila y se comprueba que corresponde al signo de apertura correspondiente. Si al finalizar de recorrer la cadena la pila está vacía entonces la expresión está equilibrada.

JAVA

Para realizar esta clase debemos importar al proyecto las bibliotecas en las que tenemos las implementación LinkedStack (aunque puede ser otra implementación
de la interfaz Stack sin ningún problema). Recuerdo cómo se hacía esto en Eclipse, que siempre suele pasar que se nos olvidan este tipo de cosas:

1. Project -> Properties -> Java Build Path -> Libraries
2. Seleccionamos la opción oportuna (Add external jar, add library...)

public class WellBalanced {
 private final static String OPEN_PARENTHESES ="{[(";
 private final static String CLOSED_PARENTHESES = "}])";
 public static void main(String [] args) {
  String prueba = "vv(hg(jij)hags{ss[dd]dd})"; //con el que probamos
  Stack<Character > pila = new LinkedStack<Character >();
  System.out.println(wellBalanced(prueba, pila)); // Se muestra por pantalla si prueba está balanceada (true) o no (false)
  
 }
 public static boolean wellBalanced(String exp, Stack <Character > stack) {
  for(int i=0; i < exp.length(); i++){
   char c = exp.charAt(i);
   if (isOpenParentheses(c)){
    stack.push(c);
   }else if (isClosedParentheses(c)){
    if (match (stack.top(), c) )  {
     stack.pop();
    } else{
     return false;
    }
   }
  }
  
  return stack.isEmpty();

 }
 public static boolean isOpenParentheses(char c) {
  return OPEN_PARENTHESES.indexOf(new Character(c).toString()) >= 0;
 }
 public static boolean isClosedParentheses(char c) {
  return CLOSED_PARENTHESES.indexOf(new Character(c).toString()) >= 0;
 }
 public static boolean match(char x, char y) {
  return OPEN_PARENTHESES.indexOf(new Character(x).toString()) ==
    CLOSED_PARENTHESES.indexOf(new Character(y).toString());
 }
}

HASKELL

wellBalanced :: String -> Bool

wellBalanced xs = wellBalanced' xs empty


wellBalanced' :: String -> Stack Char -> Bool

wellBalanced' [] s = isEmpty s

wellBalanced' (x:xs) s
   
 | isOpen x   = wellBalanced' xs (push x s)

   
 | isClosed x = if (match (top s) x ) then wellBalanced' xs (pop s) else False
   
 | otherwise = wellBalanced' xs s



isOpen x = elem x "([{"

isClosed x = elem x ")]}"



match '(' ')' = True

match '[' ']' = True

match '{' '}' = True

match _ _ = False