Pravim neki program koji treba da određuje da li je izraz tautologija, kontradikcija ili zadovoljiva.
I sada, lepo radi u nekom slučajevima kada treba redom da određuje ali kada treba da ispoštuje pravila prednosti tipa recimo u primeru
(p||q=>r)<=>(p=>r)&&(q=>r)
prvo će da radi (p||q=>r)<=>(p=>r)
pa tek ostalo a meni treba da odradi prvo (p||q=>r) pa (p=>r)&&(q=>r) i tek onda ekvivalenciju.
Recimo tako bi računalo 4+3*2 = 14
Rađeno je preko obrnute poljske notacije. Ako neko zna šta dodati kodu i gde(još sam slab sa javom a trebam da predam ovo ubrzo).


import java.util.ArrayList;
import java.util.HashMap;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ReversePolishNotation {

   // Spisak operatora
   public static final String[] OPERATORS = { "=>", "<=>", "&&", "||", "^",
         "(", ")", "^" };

   public static boolean evaluate(String expression,
         HashMap<String, Boolean> values) {
      // Dodaje default 0 i 1 vrednosti u slucaju negacije samo jedne vrednost
      values.put("0", false);
      values.put("1", true);

      // Uklanja sve razmake
      expression = expression.replaceAll("\\s+", "");

      // Pretraga karaktera za negaciju i zamenja njegovom default obrnutom
      // vrednoscu
      Pattern PATTERN = Pattern.compile("\\^[A-Za-z0-9]");
      Matcher m = PATTERN.matcher(expression);
      while (m.find()) {
         String s = m.group(0).substring(1, 2);

         if (values.get(s) == false)
            expression = expression.replaceAll("\\^[A-Za-z0-9]", "1");
         else
            expression = expression.replaceAll("\\^[A-Za-z0-9]", "0");
      }

      // Regularni izraz za splitovanje zadatog izraza po operatorima
      String regex = "((?<=\\))|(?=\\)))|((?<=\\()|(?=\\())|((?<=\\b\\w+\\b)|(?=\\b\\w+\\b))";

      String[] tokens = expression.split(regex);

      Stack<String> operators = new Stack<String>();
      Stack<Boolean> operands = new Stack<Boolean>();

      ArrayList<String> output = new ArrayList<String>();

      for (String clan : tokens) {

         if (!clan.equals(")")) {
            if (isOperator(clan))
               operators.push(clan);
            else
               output.add(clan);

         } else {
            while (operators.peek().equals("(") == false) {
               output.add(operators.pop());
            }

            operators.pop();
         }
      }

      // Racunanje and shit
      while (operators.size() != 0) {
         output.add(operators.pop());
      }

      for (String item : output) {

         if (!isOperator(item)) {

            operands.push(values.get(item));

         } else if (item.equals("=>")) {

            boolean item1 = operands.pop();
            boolean item2 = operands.pop();

            if (item2 == true && item1 == false)
               operands.push(false);
            else
               operands.push(true);

         } else if (item.equals("&&")) {

            boolean item1 = operands.pop();
            boolean item2 = operands.pop();
            if (item1 == true && item2 == true)
               operands.push(true);
            else
               operands.push(false);

         }

         else if (item.equals("||")) {

            boolean item1 = operands.pop();
            boolean item2 = operands.pop();
            if (item1 == true || item2 == true)
               operands.push(true);
            else
               operands.push(false);

         }

         else if (item.equals("^")) {

            boolean item1 = operands.pop();

            operands.push(!item1);

         }

         else if (item.equals("<=>")) {

            boolean item1 = operands.pop();
            boolean item2 = operands.pop();

            if (item1 == item2)
               operands.push(true);
            else
               operands.push(false);

         }

      }

      return operands.pop();

   }

   private static boolean isOperator(String s) {
      for (String operator : OPERATORS) {
         if (s.equals(operator))
            return true;
      }

      return false;
   }

}