import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import java.awt.Graphics;
import java.lang.Math;
import java.util.*;

public class LogikFormeln extends Applet
{
  Label l1=new Label("aussagenlogische Formel lautet:");
  TextField aufgabe_eingabe=new TextField(100);       //在这个文本框里输入要计算的式子
  Button normalform=new Button("Ergebniss anzeigen"); //显示总的计算结果的按钮

  Label tk_ergebniss=new Label("Die aussagenlogische Formel ist ............."); //显示是Tautologie或者Kontradiktion的标签
  Label nf_anzeigen1=new Label("Normalform lautet .............");       //显示用Normalform表示的计算结果
  Label nf_anzeigen2=new Label("");                                      //显示用Normalform表示的计算结果

  Label l2=new Label("Bitte hier die Wert der Variablen eingeben:");
  TextField var_wert_eingabe=new TextField(100);        //在这个文本框里输入逻辑变量的值
  Button rechnen=new Button("Die Wert anzeigen");       //对于变量的个别值，显示其结果的按钮
  Label wert_anzeigen=new Label("Das Ergebniss lautet:");   //对于变量的个别值，显示其结果的标签

  Panel p1=new Panel();
  Panel p2=new Panel();

  String aufgabe="";    //保存用户输入的逻辑表达式
  String nf="";         //保存Normalform的字符串

  public void init()
  {
    setBackground(Color.white);        //背景设成白色
    setLayout(new GridLayout(6,1));    //分成6行1列

    //布置第一行
    add(p1);
    p1.setLayout(new BorderLayout());
    p1.add(l1,BorderLayout.WEST);
    p1.add(aufgabe_eingabe,BorderLayout.CENTER);
    p1.add(normalform,BorderLayout.EAST);

    //布置第二行
    add(tk_ergebniss);

    //布置第三行
    add(nf_anzeigen1);

    //布置第四行
    add(nf_anzeigen2);

    //布置第五行
    add(p2);
    p2.setLayout(new BorderLayout());
    p2.add(l2,BorderLayout.WEST);
    p2.add(var_wert_eingabe,BorderLayout.CENTER);
    p2.add(rechnen,BorderLayout.EAST);

    //布置第六行
    add(wert_anzeigen);

    ///////////////////////////////显示总的计算结果的按钮开始////////////////////////////////////////
    normalform.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
        nf="";
        String logikformel="";     //把变量换成相应的0或1
        int var_anzahl;           //看看有多少个变量
        aufgabe=aufgabe_eingabe.getText();   //从文本框中得到字符串，即用户输入的逻辑表达式
        aufgabe=leerzeichen_entfernen(aufgabe);             //调用这个函数去掉字符串中的空格
        umwandeln_1();  //调用这个函数把用户输入的逻辑表达式变换成需要的格式，即把逻辑符号数字化，为了确定计算的优先级别

        int schritt=0;    //用来保存需要多少计算步骤，即每个不等于0和1的数字就是一步

        schritt=wieviele_operator(aufgabe);  //这个函数用来数一下表达式中有多少个已经数字化的逻辑符号，即多少步
        var_anzahl=wieviel_var(aufgabe);     //函数wieviel_var用来确定有多少个变量

        int zeile=1;           //真值表中有多少行，即2的n次方，n指变量数
        //确定真值表有多少行
        for(int i=0; i<var_anzahl; i++)
           zeile=zeile*2;

        String [] tk_test=new String[zeile]; //用来看看是不是Tautologie或者是Kontradiktion

        //计算真值表
        for(int j=0; j<zeile; j++)
        {
          logikformel=umwandeln_2(aufgabe,j,var_anzahl);  //这个函数把已经数字化的逻辑表达式用0和1把相应的变量替换掉
          //根据计算的优先级开始一步一步的算
          for(int i=1; i<=schritt; i++)
          {
            logikformel=rechnen(logikformel);  //这个函数对字符串按照优先顺序进行计算处理
          }

          tk_test[j]=logikformel;   //将每次计算的结果存在这个数组里，为了判断Tautologie或者是Kontradiktion
          normalform_func(tk_test[j],aufgabe,j,var_anzahl); //这个函数计算Normalform的表达式
        } //end of for

        tk_test_func(tk_test);    //这个函数判断是Tautologie或者是Kontradiktion
        normalform_anzeigen();    //这个函数是显示出Normalform的表达式
      }
    });
    ///////////////////////////////显示总的计算结果的按钮结束////////////////////////////////////////

    /////////////////////////////////计算用户输入值的按钮开始////////////////////////////////////////
    rechnen.addActionListener(new ActionListener()
    {
      public void actionPerformed(ActionEvent e)
      {
        String var_wert="";
        var_wert=var_wert_eingabe.getText();        //读取用户输入的变量的值
        var_wert=leerzeichen_entfernen(var_wert);   //调用这个函数去掉字符串中的空格

        String logikformel="";     //把变量换成相应的0或1
        int var_anzahl;           //看看有多少个变量
        aufgabe=aufgabe_eingabe.getText();   //从文本框中得到字符串，即用户输入的逻辑表达式
        aufgabe=leerzeichen_entfernen(aufgabe);             //调用这个函数去掉字符串中的空格
        umwandeln_1();  //调用这个函数把用户输入的逻辑表达式变换成需要的格式，即把逻辑符号数字化，为了确定计算的优先级别

        int schritt=0;    //用来保存需要多少计算步骤，即每个不等于0和1的数字就是一步
        schritt=wieviele_operator(aufgabe);  //这个函数用来数一下表达式中有多少个已经数字化的逻辑符号，即多少步
        var_anzahl=wieviel_var(aufgabe);     //函数wieviel_var用来确定有多少个变量

        logikformel=umwandeln_3(aufgabe,var_wert,var_anzahl);  //这个函数把已经数字化的逻辑表达式用0和1把相应的变量替换掉
        //根据计算的优先级开始一步一步的算
        for(int i=1; i<=schritt; i++)
        {
          logikformel=rechnen(logikformel);  //这个函数对字符串按照优先顺序进行计算处理
        }

        wert_anzeigen.setText("Das Ergebniss lautet:     "+logikformel);
      }
    });
    /////////////////////////////////计算用户输入值的按钮结束////////////////////////////////////////

  } //end of init

///////////////////////////////////显示Normalform的函数开始//////////////////////////////////
  void normalform_anzeigen()
  {
    StringTokenizer leer_entfernen=new StringTokenizer(nf,"+");
    String[] eingabe=new String[leer_entfernen.countTokens()];
    for(int i=0;i<eingabe.length;i++)
       eingabe[i]=leer_entfernen.nextToken();
    nf="";
    for(int i=0;i<eingabe.length-1;i++)
       nf +=eingabe[i]+"+";
    nf=nf+eingabe[eingabe.length-1];

    if(nf.length()<=130)
    {
      nf_anzeigen1.setText("Normalform lautet: "+nf);
      nf_anzeigen2.setText("");
    }
    else{
          nf_anzeigen1.setText("Normalform lautet: "+nf.substring(0,130));
          nf_anzeigen2.setText(nf.substring(130,nf.length()));
        }
  }
///////////////////////////////////显示Normalform的函数结束//////////////////////////////////

/////////////////////////////////计算Normalform的函数开始//////////////////////////////////
  void normalform_func(String tk_test, String st, int n, int m)
  {
    int k=0;
    char [] var_char=new char[m]; //按照从A到Z，从0到m的顺序保存变量字符
    int wieviel_buchstaben=0;
    String[] wert=new String[m];  //用0和1替代变量的数组

    for(int i=0; i<st.length(); i++)
      if((st.charAt(i)>='A')&&(st.charAt(i)<='Z'))
        wieviel_buchstaben++;

    char [] buchstabe=new char[wieviel_buchstaben];

    for(int i=0, j=0; i<st.length(); i++) //把输入的字符串里的字母存到一个字符串数组里
    {
      if((st.charAt(i)>='A')&&(st.charAt(i)<='Z'))
      {
        buchstabe[j]=st.charAt(i);
        j++;
      }
    }

    for(char i='A'; i<='Z'; i++) //确定变量字符
    {
      for(int j=0; j<wieviel_buchstaben; j++)
      {
        if(i==buchstabe[j])
        {
          var_char[k]=i;
          k++;
          break;
        }
      }
    }

    int rest, zaehler;
    zaehler=n;
    for(int i=m-1; i>=0; i--)
    {
      rest=zaehler%2;
      if(rest==1) wert[i]="1";
      else wert[i]="0";
      zaehler=zaehler/2;
    }

    for(char i='A'; i<='Z'; i++)
    {
      for(int j=0; j<m; j++)
      {
        if((var_char[j]==i)&&(wert[j].equals("1"))&&(tk_test.equals("1 ")))
        {
          if(j<(m-1))  nf=nf+String.valueOf(i)+"*";
          else     nf=nf+String.valueOf(i)+"+";
        }
        if((var_char[j]==i)&&(wert[j].equals("0"))&&(tk_test.equals("1 ")))
        {
          if(j<(m-1))  nf=nf+"!"+String.valueOf(i)+"*";
          else     nf=nf+"!"+String.valueOf(i)+"+";
        }
      }
    } //end of for
  }
/////////////////////////////////计算Normalform的函数结束//////////////////////////////////

/////////////////////////////判断是Tautologie或者是Kontradiktion的函数开始///////////////////////////////////
  void tk_test_func(String [] st)
  {
    int t1=0;
    int t2=0;
    for(int i=0; i<st.length; i++)
      if(st[i].equals("0 "))
         t1++;
    for(int i=0; i<st.length; i++)
      if(st[i].equals("1 "))
         t2++;
    if(t1==st.length)
      tk_ergebniss.setText("Die aussagenlogische Formel ist Kontradiktion, aber keine Tautologie");
    if(t2==st.length)
      tk_ergebniss.setText("Die aussagenlogische Formel ist Tautologie, aber keine Kontradiktion");
    if((t1!=st.length)&&(t2!=st.length))
      tk_ergebniss.setText("Die aussagenlogische Formel ist keine Tautologie und keine Kontradiktion");
  }
/////////////////////////////判断是Tautologie或者是Kontradiktion的函数结束///////////////////////////////////

///////////////////////////////////////字符串计算处理函数开始///////////////////////////////////////
  String rechnen(String st)
  {
    int j=0;
    String [] st_operator=new String[wieviele_operator(st)]; //给数字化逻辑符号数组分配空间，字符串型是为了找出位置
    int [] operator=new int[wieviele_operator(st)];  //给数字化逻辑符号数组分配空间，整数型是为了算出最大值
    int index=0;      //指出要优先计算的位置
    String zwischen_ergebniss="";

    StringTokenizer wieviel=new StringTokenizer(st," ");
    String[] eingabe=new String[wieviel.countTokens()];
    for(int i=0;i<eingabe.length;i++)
       eingabe[i]=wieviel.nextToken();

    //给数字化逻辑符号数组赋值
    for(int i=0;i<eingabe.length;i++)
    {
      if((eingabe[i].charAt(eingabe[i].length()-1)=='3')||(eingabe[i].charAt(eingabe[i].length()-1)=='4')||
         (eingabe[i].charAt(eingabe[i].length()-1)=='5')||(eingabe[i].charAt(eingabe[i].length()-1)=='6')||
         (eingabe[i].charAt(eingabe[i].length()-1)=='7')||(eingabe[i].charAt(eingabe[i].length()-1)=='2'))
      {
        st_operator[j]=eingabe[i];
        operator[j]=Integer.parseInt(st_operator[j]);
        j++;
      }
    }

    //找出优先计算的逻辑符号所处的位置
    int m;
    m=max(operator);
    for(int i=eingabe.length-1; i>=0; i--)  //必须从后面向前找，因为非门可以有无限个
    {
      if(st_operator[m].equals(eingabe[i]))
      {
        index=i;
        break;
      }
    }

    if(st_operator[m].charAt(st_operator[m].length()-1)=='6')
      zwischen_ergebniss=f_und(eingabe,index,eingabe[index-1],eingabe[index+1]);
    if(st_operator[m].charAt(st_operator[m].length()-1)=='5')
      zwischen_ergebniss=f_oder(eingabe,index,eingabe[index-1],eingabe[index+1]);
    if(st_operator[m].charAt(st_operator[m].length()-1)=='4')
      zwischen_ergebniss=f_implikation(eingabe,index,eingabe[index-1],eingabe[index+1]);
    if(st_operator[m].charAt(st_operator[m].length()-1)=='3')
      zwischen_ergebniss=f_aequivalenz(eingabe,index,eingabe[index-1],eingabe[index+1]);
    if(st_operator[m].charAt(st_operator[m].length()-1)=='7')
      zwischen_ergebniss=f_nicht(eingabe,index,eingabe[index+1]);
    if(st_operator[m].charAt(st_operator[m].length()-1)=='2')
      zwischen_ergebniss=f_antivalenz(eingabe,index,eingabe[index-1],eingabe[index+1]);

    return zwischen_ergebniss;
  }
///////////////////////////////////////字符串计算处理函数结束///////////////////////////////////////

///////////////////////////////////antivalenz函数开始///////////////////////////////////
  String f_antivalenz(String [] st1, int index, String st2, String st3)
  {
    String hilf="";

    if(((st2.charAt(st2.length()-1)=='1')&&(st3.charAt(st3.length()-1)=='1'))||
       ((st2.charAt(st2.length()-1)=='0')&&(st3.charAt(st3.length()-1)=='0')))
    {
      for(int i=0; i<index-1; i++) hilf=hilf+st1[i]+" ";
      hilf=hilf+"0 ";
      for(int i=index+2; i<st1.length; i++) hilf=hilf+st1[i]+" ";
    }
    else{
          for(int i=0; i<index-1; i++) hilf=hilf+st1[i]+" ";
          hilf=hilf+"1 ";
          for(int i=index+2; i<st1.length; i++) hilf=hilf+st1[i]+" ";
        }

    return hilf;
  }
///////////////////////////////////antivalenz函数结束///////////////////////////////////

///////////////////////////////////oder函数开始///////////////////////////////////
  String f_oder(String [] st1, int index, String st2, String st3)
  {
    String hilf="";

    if((st2.charAt(st2.length()-1)=='0')&&(st3.charAt(st3.length()-1)=='0'))
    {
      for(int i=0; i<index-1; i++) hilf=hilf+st1[i]+" ";
      hilf=hilf+"0 ";
      for(int i=index+2; i<st1.length; i++) hilf=hilf+st1[i]+" ";
    }
    else{
          for(int i=0; i<index-1; i++) hilf=hilf+st1[i]+" ";
          hilf=hilf+"1 ";
          for(int i=index+2; i<st1.length; i++) hilf=hilf+st1[i]+" ";
        }

    return hilf;
  }
///////////////////////////////////oder函数结束///////////////////////////////////

///////////////////////////////////und函数开始///////////////////////////////////
  String f_und(String [] st1, int index, String st2, String st3)
  {
    String hilf="";

    if((st2.charAt(st2.length()-1)=='1')&&(st3.charAt(st3.length()-1)=='1'))
    {
      for(int i=0; i<index-1; i++) hilf=hilf+st1[i]+" ";
      hilf=hilf+"1 ";
      for(int i=index+2; i<st1.length; i++) hilf=hilf+st1[i]+" ";
    }
    else{
          for(int i=0; i<index-1; i++) hilf=hilf+st1[i]+" ";
          hilf=hilf+"0 ";
          for(int i=index+2; i<st1.length; i++) hilf=hilf+st1[i]+" ";
        }

    return hilf;
  }
///////////////////////////////////und函数结束///////////////////////////////////

///////////////////////////////////implikation函数开始///////////////////////////////////
  String f_implikation(String [] st1, int index, String st2, String st3)
  {
    String hilf="";

    if((st2.charAt(st2.length()-1)=='1')&&(st3.charAt(st3.length()-1)=='0'))
    {
      for(int i=0; i<index-1; i++) hilf=hilf+st1[i]+" ";
      hilf=hilf+"0 ";
      for(int i=index+2; i<st1.length; i++) hilf=hilf+st1[i]+" ";
    }
    else{
          for(int i=0; i<index-1; i++) hilf=hilf+st1[i]+" ";
          hilf=hilf+"1 ";
          for(int i=index+2; i<st1.length; i++) hilf=hilf+st1[i]+" ";
        }

    return hilf;
  }
///////////////////////////////////implikation函数结束///////////////////////////////////

///////////////////////////////////aequivalenz函数开始///////////////////////////////////
  String f_aequivalenz(String [] st1, int index, String st2, String st3)
  {
    String hilf="";

    if(((st2.charAt(st2.length()-1)=='1')&&(st3.charAt(st3.length()-1)=='1'))||
       ((st2.charAt(st2.length()-1)=='0')&&(st3.charAt(st3.length()-1)=='0')))
    {
      for(int i=0; i<index-1; i++) hilf=hilf+st1[i]+" ";
      hilf=hilf+"1 ";
      for(int i=index+2; i<st1.length; i++) hilf=hilf+st1[i]+" ";
    }
    else{
          for(int i=0; i<index-1; i++) hilf=hilf+st1[i]+" ";
          hilf=hilf+"0 ";
          for(int i=index+2; i<st1.length; i++) hilf=hilf+st1[i]+" ";
        }

    return hilf;
  }
///////////////////////////////////aequivalenz函数结束///////////////////////////////////

///////////////////////////////////nicht函数开始///////////////////////////////////
  String f_nicht(String [] st1, int index, String st2)
  {
    String hilf="";

    if((st2.charAt(st2.length()-1)=='1'))
    {
      for(int i=0; i<index; i++) hilf=hilf+st1[i]+" ";
      hilf=hilf+"0 ";
      for(int i=index+2; i<st1.length; i++) hilf=hilf+st1[i]+" ";
    }
    else{
          for(int i=0; i<index; i++) hilf=hilf+st1[i]+" ";
          hilf=hilf+"1 ";
          for(int i=index+2; i<st1.length; i++) hilf=hilf+st1[i]+" ";
        }

    return hilf;
  }
///////////////////////////////////nicht函数结束///////////////////////////////////

//////////////////////////////找出数组中最大那一项的index开始////////////////////////////////
  int max(int n[])
  {
    int m=n[0];
    int i=0;
    for(int j=0; j<n.length; j++)
    {
      if(n[j]>m) m=n[j];
    }
    for(int j=0; j<n.length; j++)
    {
      if(m==n[j]) i=j;
    }
    return i;
  }
//////////////////////////////找出数组中最大那一项的index结束////////////////////////////////

////////////////////////////多少计算步骤函数开始///////////////////////////////////////
  int wieviele_operator(String st)
  {
    int n=0;

    StringTokenizer wieviel=new StringTokenizer(st," ");
    String[] eingabe=new String[wieviel.countTokens()];
    for(int i=0;i<eingabe.length;i++)
       eingabe[i]=wieviel.nextToken();

    //这个循环用来计算有多少步
    for(int i=0;i<eingabe.length;i++)
    {
      if((eingabe[i].charAt(eingabe[i].length()-1)=='3')||(eingabe[i].charAt(eingabe[i].length()-1)=='4')||
         (eingabe[i].charAt(eingabe[i].length()-1)=='5')||(eingabe[i].charAt(eingabe[i].length()-1)=='6')||
         (eingabe[i].charAt(eingabe[i].length()-1)=='7')||(eingabe[i].charAt(eingabe[i].length()-1)=='2'))
         n++;
    }
    return n;
  }
////////////////////////////多少计算步骤函数结束///////////////////////////////////////

///////////////////////逻辑符号数字化函数开始///////////////////////////////////////
  void umwandeln_1()
  {
    int vorfahren=0;
    int antivalenz=2;     //#
    int aequivalenz=3;    //<=>
    int implikation=4;    //->
    int oder=5;
    int und=6;
    int nicht=7;
    String st="";

    for(int i=0; i<aufgabe.length(); i++)
    {
      if(aufgabe.charAt(i)=='(')
      {
        vorfahren +=10;
      }
      if(aufgabe.charAt(i)==')')
      {
        vorfahren -=10;
      }
      if(aufgabe.charAt(i)=='!')
      {
        nicht +=vorfahren;
        st=st+String.valueOf(nicht)+" ";
        nicht -=vorfahren;
      }
      if(aufgabe.charAt(i)=='*')
      {
        und +=vorfahren;
        st=st+String.valueOf(und)+" ";
        und -=vorfahren;
      }
      if(aufgabe.charAt(i)=='+')
      {
        oder +=vorfahren;
        st=st+String.valueOf(oder)+" ";
        oder -=vorfahren;
      }
      if(aufgabe.charAt(i)=='-')
      {
        implikation +=vorfahren;
        st=st+String.valueOf(implikation)+" ";
        implikation -=vorfahren;
      }
      if(aufgabe.charAt(i)=='<')
      {
        aequivalenz +=vorfahren;
        st=st+String.valueOf(aequivalenz)+" ";
        aequivalenz -=vorfahren;
      }
      if(aufgabe.charAt(i)=='#')
      {
        antivalenz +=vorfahren;
        st=st+String.valueOf(antivalenz)+" ";
        antivalenz -=vorfahren;
      }
      if((aufgabe.charAt(i)>='A')&&(aufgabe.charAt(i)<='Z'))
      {
        st=st+String.valueOf(aufgabe.charAt(i))+" ";
      }
    } //end of for
    aufgabe=st;
  }
///////////////////////逻辑符号数字化函数结束///////////////////////////////////////

//////////////////////////////用0和1替代变量函数开始////////////////////////////////////////
  String umwandeln_2(String st, int n, int m)
  {
    int k=0;
    char [] var_char=new char[m]; //按照从A到Z，从0到m的顺序保存变量字符
    int wieviel_buchstaben=0;
    String logik="";              //用0和1替代后的用户输入的逻辑表达式
    String[] wert=new String[m];  //用0和1替代变量的数组

    for(int i=0; i<st.length(); i++)
      if((st.charAt(i)>='A')&&(st.charAt(i)<='Z'))
        wieviel_buchstaben++;

    char [] buchstabe=new char[wieviel_buchstaben];

    for(int i=0, j=0; i<st.length(); i++) //把输入的字符串里的字母存到一个字符串数组里
    {
      if((st.charAt(i)>='A')&&(st.charAt(i)<='Z'))
      {
        buchstabe[j]=st.charAt(i);
        j++;
      }
    }

    for(char i='A'; i<='Z'; i++) //确定变量字符
    {
      for(int j=0; j<wieviel_buchstaben; j++)
      {
        if(i==buchstabe[j])
        {
          var_char[k]=i;
          k++;
          break;
        }
      }
    }

    int rest, zaehler;
    zaehler=n;
    for(int i=m-1; i>=0; i--)
    {
      rest=zaehler%2;
      if(rest==1) wert[i]="1";
      else wert[i]="0";
      zaehler=zaehler/2;
    }

    for(int i=0; i<st.length(); i++)
    {
      if((st.charAt(i)>='A')&&(st.charAt(i)<='Z'))
      {
        for(int j=0; j<m; j++)
        {
          if(var_char[j]==st.charAt(i)) logik=logik+wert[j];
        }
      }
      else logik=logik+String.valueOf(st.charAt(i));
    }

    return logik;
  }
//////////////////////////////用0和1替代变量函数结束////////////////////////////////////////

//////////////////////////////////函数umwandeln_3开始/////////////////////////////////
  String umwandeln_3(String st,String var_wert,int var_anzahl)
  {
    String [] var_char=new String[var_anzahl]; //按照从A到Z，从0到m的顺序保存变量字符
    String logik="";              //用0和1替代后的用户输入的逻辑表达式
    String[] wert=new String[var_anzahl];  //用0和1替代变量的数组

    StringTokenizer leer_entfernen=new StringTokenizer(var_wert,",");
    String[] eingabe=new String[leer_entfernen.countTokens()];
    for(int i=0;i<eingabe.length;i++)
       eingabe[i]=leer_entfernen.nextToken();

    for(int i=0; i<var_anzahl; i++)
    {
      var_char[i]=String.valueOf(eingabe[i].charAt(0));
      wert[i]=String.valueOf(eingabe[i].charAt(2));
    }

    for(int i=0; i<st.length(); i++)
    {
      if((st.charAt(i)>='A')&&(st.charAt(i)<='Z'))
      {
        for(int j=0; j<var_anzahl; j++)
        {
          if(var_char[j].equals(String.valueOf(st.charAt(i)))) logik=logik+wert[j];
        }
      }
      else logik=logik+String.valueOf(st.charAt(i));
    }

    return logik;
  }
//////////////////////////////////函数umwandeln_3结束/////////////////////////////////

/////////////////////////////////////确定表达式中有多少个变量的函数开始///////////////////////
  int wieviel_var(String st)
  {
    int wieviel_buchstaben=0;
    int wievielvar=0;

    for(int i=0; i<st.length(); i++)
      if((st.charAt(i)>='A')&&(st.charAt(i)<='Z'))
        wieviel_buchstaben++;

    char [] buchstabe=new char[wieviel_buchstaben];
    wievielvar=wieviel_buchstaben;

    for(int i=0, j=0; i<st.length(); i++) //把输入的字符串里的字母存到一个字符串数组里
    {
      if((st.charAt(i)>='A')&&(st.charAt(i)<='Z'))
      {
        buchstabe[j]=st.charAt(i);
        j++;
      }
    }

    int n=-1;

    for(char i='A'; i<='Z'; i++) //看看有多少变量
    {
      n=-1;
      for(int j=0; j<wieviel_buchstaben; j++)
        if(i==buchstabe[j]) n++;
      if(n!=-1) wievielvar=wievielvar-n;
    }

    return wievielvar;
  }
/////////////////////////////////////确定表达式中有多少个变量的函数结束///////////////////////

////////////////////////////去掉字符串中的空格函数开始//////////////////////////////////////////
  String leerzeichen_entfernen(String st)
  {
    String hilf="";
    StringTokenizer leer_entfernen=new StringTokenizer(st," ");
    String[] eingabe=new String[leer_entfernen.countTokens()];
    for(int i=0;i<eingabe.length;i++)
       eingabe[i]=leer_entfernen.nextToken();
    for(int i=0;i<eingabe.length;i++)
       hilf +=eingabe[i];
    return hilf;
  }
////////////////////////////去掉字符串中的空格函数结束//////////////////////////////////////////

} //end of class LogikFormeln

//////////  2代表Antivalenz，3代表Aequivalenz，4代表Implikation，5代表Oder，6代表Und，7代表Nicht ///////////////////
//////////  逢左括号 ( 加10，逢右括号 ) 减10                                    ///////////////////