جاوا ۾ ڳڻپيوڪر صرف lvl 10 JavaRush جي بنياد سان (3Kyu چيلنج CodeWars تي)

هڪ ٻيو مضمون منهنجي ايڊونچر بابت CodeWars تي. ان لاءِ اسان هڪ ايليمينٽري ڳڻپيوڪر جي ڪارڪردگيءَ کي لاڳو ڪريون ٿا: هڪ سادو ڳڻپيوڪر ٺاهيو جنهن کي آپريٽرن جي اسٽرنگ ()، +، -، *، / . مون وٽ صرف 10+ ليول جا JavaRush منهنجي بيلٽ هيٺ آهن، تنهن ڪري ڪوڊ تمام مشڪل آهي، پر اهو مڪمل طور تي ڪم ڪري ٿو. ڪم، جيئن توهان محسوس ڪيو هوندو، آهي CodeWars ويب سائيٽ . هن جو درجو 3kyu آهي . مان توهان کي هڪ خانگي پيغام ۾ لنڪ ڏئي سگهان ٿو. هتي طريقن ۽ عملن جي هڪ جزوي فهرست آهي جيڪا مون کي مدد ڪئي آهي:

1. ورجائي. اهو عمل جنهن ۾ هڪ طريقو پاڻ کي سڏيندو آهي (پهريون ڀيرو ان کي استعمال ڪندي :)) هن معاملي ۾ قوس کان نجات حاصل ڪرڻ ضروري آهي.
2. طريقه Stringهڪ trim(), split(), substring(), replace().
3. گڏ ڪرڻ جا بنيادي طريقا List.
4. انهي سان گڏ ٽائپ ڪنورشن Doubleکان String۽ ان کان.

اصول ۾، هي ڪافي آهي. پاڻ ڪوڊ ڏانهن وڃڻ کان اڳ، مان توهان کي ٻڌايان ٿو ته مون کي ڪهڙيون مشڪلاتون آيون آهن. گهڻو ڪري، هي اهو حڪم آهي جنهن ۾ حساب ڪتاب ڪيا ويندا آهن، پهرين ۾ مون هڪ معياري اسڪيم ٺاهيو * > / > + > -، پر مون محسوس ڪيو ته، مثال طور، هن اختيار سان: 12/6 * 32/2, پروگرام پهريون ڀيرو ضرب ( 6*32) انجام ڏيندو ۽ هر شيء هيٺ ٿي ويندي، تنهنڪري حڪم هن طرح ٿي ويو: * > / > + > -. ٻن ڪلاڪن کان پوءِ مون کي سڀ کان وڏو پٿر نظر آيو -. مختلف پوزيشن ۾ ۽ مختلف مجموعن سان، هن هر شيء کي تبديل ڪيو . (اها، يقينا، منهنجي غلطي آهي، ڇاڪاڻ ته، مثال طور:، -34فهرست جي هڪ سيل ۾ نه آهي، پر ٻن ۾: هڪ ۾، - ٻئي ۾، 34). انهي جي ڪري، اسان کي حساب ۾ 2 اضافي منطق لکڻيون هيون -، عام طور تي، توهان هن کي ڪوڊ ۾ ڏسندا. مان ڪوڊ ۾ غير ضروري تبصرن لاءِ معافي وٺان ٿو، مان چاهيان ٿو ته پنهنجي سوچ جي ٽرين کي جيترو ٿي سگهي ظاهر ڪريان ۽ وضاحت ڪريان ته اتي ڇا ٿي رهيو آهي.

import java.util.*;

public class Calculator {
    public static void main(String[] args) {
        String num = "2 / ( ( 2 + 0 ) * 1 ) - 6";
        System.out.println(evaluate(num));
    }

    public static Double evaluate(String expression) {

//  Этап 1
//  На данном этапе преобразуем нашу строку в список строк, через совмещение цикла for-each и метода split(),
//  также используем метод trim(), чтобы избавиться от пробелов по краям.
//  Обратите внимание, что каждым вторым элиментом я добавляю " ". Для того, чтобы потом мне было легче работать со строкой

        List<string> strList = new ArrayList<>();
        for (String listElement : expression.trim().split(" ")) {
            strList.add(listElement);
            strList.add(" ");
        }
        strList.remove(strList.size() - 1);
//        for (String x : strList) System.out.print(x + "");
//        System.out.println();
//        После того, How дочитаете code до конца, расскоментируйте две верхние строчки
//        и посмотрите How работает рекрусия

//  Этап 2
//  Производим поиск символа "(" в списке если находим, то преобразуем все символы от '(' до последнего ')' в строку.
//  Надо быть внимательными и проверить на случай двух контрукций: 1) (())  2) ()().
//  P.S. После получения строки мы используем РЕКУРСИЮ (метод вызывает сам себя). Таким образом будем находить произведение скобок.

        if (strList.indexOf("(") != -1) {
//          Если "(" обнаружен, ищем подходящую конструкцию используя цикл.

            for (int i = strList.indexOf("(") + 1; i < strList.size() - 1; i++) {
//
//              Конструкция 1: первым элиментом, который мы отыскали были вторые "("
                String recursion = "";
                if (strList.get(i).equals("(")) {
                    for (int j = i; j < strList.lastIndexOf(")"); j++) {
                        recursion += strList.get(j);
                    }
                    // сверху считывали последовательность находящуюся в скобках (()) До lastIndex element
                    String test = expression.substring(expression.indexOf("("), expression.lastIndexOf(")") + 1);
                    // test - последовательность How и сверху, но с добавлением скобок по краям

                    // т.к. наш метод evaluate() возвращает Double, мы должны преобразовать результат рекрусии в String;
                    String testRecursion = String.valueOf(evaluate(recursion));
                    expression = expression.replace(test, testRecursion);
                    // преобразовали нашу строку с использование рекруси. Избавorсь от первых скобок
                    strList.removeAll(strList);
                    for (String newElement : expression.trim().split(" ")) {
                        strList.add(newElement);
                        strList.add(" ");
                    }
                    // Тут очищаем наш список и сново его заполняем (но уже раскрыв первые скобки)
                }

//                Конструкция 2: первым элиментом, который мы отыскали был  ")"
                String recursion2 = "";
                if (strList.get(i).equals(")")) {

                    for (int j = strList.indexOf("(") + 1; j < strList.indexOf(")"); j++) {
                        recursion2 += strList.get(j);
                    }
                    String test2 = expression.substring(expression.indexOf("("), expression.lastIndexOf(")") + 1);
                    String testRecursion2 = String.valueOf(evaluate(recursion2));
                    expression = expression.replace(test2, testRecursion2);
                    for (String newElement : expression.trim().split(" ")) {
                        strList.add(newElement);
                        strList.add(" ");
                    }
                    // Тут повторor тот же алгоритм, что и в первой конструкции
                }
            }
        }

//  Этап 3
//  Заключительный этап на котором мы будем реализовывать сами вычесления (*/-+)
//  Всю реализацию помещаем в цикл while ( который прекратиться, если все действия будут выполнены (соответственно в списке останется 1 элемент)).
//  Внимательно посмотрите на порядок операций: 1)/ 2)* 3)- 4)+

//        System.out.println(expression + "-------expression-");
//        System.out.println();
        // создаем очередной список для реализации вычеслений, на этот раз без добавления " ".
        List<string> stringList2 = new ArrayList<>();
        for (String element : expression.trim().split(" ")) {
            stringList2.add(element);
        }


        while (stringList2.size() != 0) {
//          работаем со списком: глубоком этапе рекрусии обрабатываем:  (2+0)
//          на среднем: 1 * 1  "or вот этой части уравнения "( ( 2 + 0 ) * 1 ) "
//          Посмтортите сами
//            for (String x : stringList2) System.out.print(x );
//            System.out.println();

            // наш Double :) Также стоит обратить внимание, что для получения класса обертки мы используем не
            // Double.parseDouble() а Double.valueOf()
             Double result = 0d;

//  Сами алгоритмы вычеслений, впринципе понятны, поэтому не буду их комментировать.
//  Однако обратите внимание на очередность, особенно при вычетании (там instead of 1 условия, 3)
//  Если что в комментариях под постом немного объясню, если кто-нибудь дочитает до сюда и у него будет желание)
            if (stringList2.indexOf("/") != -1) {
                int index = stringList2.indexOf("/");
                result = Double.valueOf(stringList2.get(index - 1)) / Double.valueOf(stringList2.get(index + 1));
                stringList2.add(index - 1, String.valueOf(result));
                stringList2.remove(index + 2);
                stringList2.remove(index + 1);
                stringList2.remove(index);
            }
            else if (stringList2.indexOf("*") != -1) {
                int index = stringList2.indexOf("*");
                result = Double.valueOf(stringList2.get(index - 1)) * Double.valueOf(stringList2.get(index + 1));
                stringList2.add(index - 1, String.valueOf(result));
                stringList2.remove(index + 2);
                stringList2.remove(index + 1);
                stringList2.remove(index);
            }
            else if (stringList2.indexOf("-") != -1) {
                int index = stringList2.indexOf("-");
                int lastIndex = stringList2.lastIndexOf("-");
                if (index == 0) {
                    result = 0.0 - Double.valueOf(stringList2.get(index + 1));
                    stringList2.add(0, String.valueOf(result));
                    stringList2.remove(2);
                    stringList2.remove(1);
                }
                else if ((lastIndex-2>0) && (stringList2.get(lastIndex-2).equals("-"))){
                    result = Double.valueOf(stringList2.get(lastIndex + 1)) + Double.valueOf(stringList2.get(lastIndex - 1));
                    stringList2.add(lastIndex - 1, String.valueOf(result));
                    stringList2.remove(lastIndex + 2);
                    stringList2.remove(lastIndex + 1);
                    stringList2.remove(lastIndex);
                }
                else {
                    result = Double.valueOf(stringList2.get(index - 1)) - Double.valueOf(stringList2.get(index + 1));
                    stringList2.add(index - 1, String.valueOf(result));
                    stringList2.remove(index + 2);
                    stringList2.remove(index + 1);
                    stringList2.remove(index);
                }
            }
            else if (stringList2.indexOf("+") != -1) {
                int index = stringList2.indexOf("+");
                result = Double.valueOf(stringList2.get(index - 1)) + Double.valueOf(stringList2.get(index + 1));
                stringList2.add(index - 1, String.valueOf(result));
                stringList2.remove(index + 2);
                stringList2.remove(index + 1);
                stringList2.remove(index);
            }

            // Вот тут все немного коряво. (На всякий случий проверял отсутствие (*/+-))
            if ((stringList2.indexOf("*") == -1) && (stringList2.indexOf("/") == -1) && (stringList2.indexOf("+") == -1) && (stringList2.indexOf("-") == -1)) {
                return result;
            }
        }
        return Double.valueOf(stringList2.get(0));
    }
}
</string></string>

هر ڪنهن جي مهرباني جنهن پڙهي ۽ تبصرو ڇڏي ڏنو) جيڪڏهن ڪي رايا آهن، ۽ گهڻو ڪري اتي موجود آهن، مون کي انهن کي ٻڌي خوشي ٿيندي)