लेखन स्ट्रिंग मूल्यांकन कार्य

Question

मैं एक स्ट्रिंग मूल्यांकन कार्य अर्थात

evaluate("4 + 1") ; // returns 5 
evaluate("4 + 1 + 3") ; // returns 8 
evaluate("4 + 1 * 3") ; // returns 7 (not 15) 

The operators are + -/and * 

लिखने के लिए कोशिश कर रहा हूँ मेरी प्रारंभिक हालांकि रेगुलर एक्सप्रेशन का उपयोग करने के लिए ऑपरेटरों और इन मिलान किया जा सकता के रूप में अंक एकत्र करने के लिए किया गया था। और उस जानकारी को ढूंढने के बाद, किसी भी तरह /* ओवी -+ ऑपरेटरों को प्राथमिकता देने का एक तरीका पता लगाएं।

यहाँ मैं कैसे शुरू कर दिया है:

static String regex = "([\\+\\*-/])+"; 
static String digitRegex = "(\\d)+"; 

public static void main(String[] args) { 
    System.out.println(getOperators("4 + 1 * 3")); 
} 

public static List<String> getOperators(String input) { 
    Pattern p = Pattern.compile(regex); 
    Matcher matcher = p.matcher(input); 

    List<String> operatorList = new ArrayList<String>(); 

    int count = 0; 
    while (matcher.find()){ 
     if (matcher.group(count) != null && matcher.group(count).trim().length() > 0) { 
     operatorList.add(matcher.group(count)); 
     count++; 
     } 
    } 

    return operatorList; 
} 

अब मैं एक ही तर्क का प्रयोग अंक निकालने के लिए एक और तरीका लिख ​​सकते हैं।

public static List<Integer> getDigits(String input) { 
     Pattern p = Pattern.compile(digitRegex); 
     Matcher matcher = p.matcher(input); 

     List<Integer> digitList = new ArrayList<Integer>(); 

     int count = 0; 
     while (matcher.find()) { 
      if (matcher.group(count) != null && matcher.group(count).trim().length() > 0) { 
       digitList.add(Integer.valueOf(matcher.group(count))); 
       count++; 
      } 
     } 

     return digitList; 
    } 

अब वह हिस्सा है जहां मैं फंस गया हूं। # 1 यह उपरोक्त विधि तीसरा उदाहरण पर विफल रहता है:

evaluate("4 + 1 * 3") ; // returns 7 (not 15) 

और इस # 2 यहां तक ​​कि अगर मैं पिछले उदाहरण की कोशिश, मैं यह समझ नहीं सकता बाहर कैसे उन्हें सही क्रम में डाल करने के लिए।

क्या मैं सही रास्ते पर हूं, क्या किसी के पास कुछ उपयोगी सलाह है कृपया साझा करें?

Answer 1

मैंने यहां कुछ लिखा है ... मान लें कि त्वरित & गंदा एक अल्पसंख्यक है ...
हर तरह से, आपको इसे "जैसा है" का उपयोग नहीं करना चाहिए। यह "फिक्सिंग" की जरूरत है - संख्या/गणित-आपरेशन के पढ़ने StringTokenizer का उपयोग किया जाना चाहिए - लेकिन मैं आप के लिए तकनीकी के छोड़ देंगे;)

public class NewClass { 

    public static int evaluate(String str){ 
     if("".equals(str)){ 
      return 0; 
     } 
     else if(str.length() == 1){ 
      return Integer.valueOf(str); 
     } 
     else{ 
      String _a = String.valueOf(str.charAt(0)); 
      String _b = String.valueOf(str.charAt(1)); 
      if("+".equals(_b) || "-".equals(_b)){ 
       if("+".equals(_b)){ 
        return Integer.valueOf(_a) + evaluate(str.substring(2)); 
       } 
       else{// "-" 
        return Integer.valueOf(_a) - evaluate(str.substring(2)); 
       } 
      } 
      else{// "*" or "/" 
       boolean isMulti = ("*".equals(_b)); 
       String _c = String.valueOf(str.charAt(2));     
       Integer tmp = 0; 
       if(isMulti){ 
        tmp = Integer.valueOf(_a) * Integer.valueOf(_c); 
       } 
       else{ 
        tmp = Integer.valueOf(_a)/Integer.valueOf(_c); 
       } 
       String new_str = String.valueOf(tmp) + str.substring(3);     
       return evaluate(new_str); 
      } 
     } 
    } 

    public static void main(String[] args){   
     String e = "4+1*3"; 
     int t = evaluate(e); 
     System.out.println(e + " = "+t); 
    } 

} 

Answer 2

आप operator precedence parser चाहते हैं। यह एक बहुत ही आम टेबल-आधारित पार्सर है जिसे आप वही करना चाहते हैं जो आप चाहते हैं। असल में, आप ऑपरेटर की तुलना किसी स्टैक के शीर्ष पर स्कैन किए जाने की तुलना करते हैं, और स्टैक को कम करने का चयन करें (यानी, गणित करें और परिणाम को स्टैक पर वापस दबाएं), या ऑपरेटर को दबाएं।

एक अतिरिक्त बोनस के रूप में, ओपीपी लिखना आसान और मजेदार है। आप कम अतिरिक्त प्रयास के साथ कंस्ट्रैसिस आदि के लिए समर्थन जोड़ सकते हैं।

संपादित करें - मैंने बस उस विकी लेख को पढ़ा है। यह भयानक है।

इस प्रकार के पार्सर के अन्य उदाहरण खोजें।

संपादित करें 2 -

This one shows a sample in c. Note the table.

This one is pretty good.

और याद रखें, आप ऑपरेटरों की एक छोटी संख्या का समर्थन कर रहे हैं, इसलिए धमकाया नहीं मिलता। इसके अलावा, एक टेबल लागू करने के बाद यह वही है।