Рекурсивное нахождение значения String с карты

Question

У меня есть хэш-карта, содержащая ключ и значение <String, String>,

т.е. mapValue:

mapValue.put("A","B-7");
mapValue.put("B","START+18");
mapValue.put("C","A+25");

Теперь я хочу оценить выражение для 'C', Таким образом, для Cвыражение будет заменено на (((START+18)-7)+25),

Так что если любой метод, я передам строку C, он должен вернуть строку "(((START+18)-7)+25)" и также я хочу оценить это согласно приоритету.

Спасибо

Answer 1

Обычно логика такой функции (при условии, что вы знаете возможные операции и синтаксис строгий) может выглядеть следующим образом:

public String eval(HashMap<String, String> mapValue, String variable) {
    //get expression to be evaluated
    String tmp = mapValue.get(variable); 
    // For each knwon operation
    for (String op : OPERATIONS) { 
        // split expression in operators in Array
        String[] vars = tmp.split("\\" + op); 
        // for each Element of splitted expr. Array
        for (int i = 0; i < vars.length; i++) { 
            //Check if Element is a valid key in HashMap
            if (mapValue.containsKey(vars[i])) { 
                //if it is replace element with result of iteration
                vars[i] = eval(mapValue, vars[i]); // DO ITERATION
            }
            //if Element is not a valid key in has do nothing
        }
        //Join splitted string with proper operator
        tmp = join(vars, op);
    }
    //return in parenthesis
    return "(" + tmp + ")";
}

Результатом 'eval(mapValue,"C") "будет:

(((START+18)-7)+25)

Некоторая функция короткого соединения может быть реализована следующим образом:

public String join(String[] arr, String d) {
    String result = arr[0];
    int i = 1;
    while (i < arr.length) {
        result += d + arr[i];
        i++;
    }
    return result;
}

Весь приведенный выше код предназначен для иллюстрации логики, поскольку следует использовать некоторую обработку исключений, более совершенные операции со строками и т. Д.

Надеюсь, поможет

Ура!

Answer 2

Как уже упоминалось в комментариях, я бы не рекомендовал рекурсию - это может привести к исключениям stackru-исключений, если рекурсия становится слишком глубокой.

Также я бы порекомендовал не использовать строковые уравнения. Строки анализируются медленно и могут привести к непредвиденным результатам (как упоминалось в @rtruszk, "START" содержит переменную "A").

Я создал пример в качестве моей рекомендации:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;


public class X {

    static interface Expression {

    }

    static class Combination implements Expression {
        Expression[] values;

        public Combination(Expression... values) {
            this.values = values;
        }

        @Override
        public String toString() {
            return "?";
        }
    }

    static class Reference implements Expression {
        private String reference;

        public Reference(String reference) {
            this.reference = reference;
        }

        @Override
        public String toString() {
            return reference;
        }
    }

    static class Number implements Expression {
        private int value;

        public Number(int value) {
            this.value = value;
        }

        @Override
        public String toString() {
            return ""+value;
        }
    }

    public static void main(String[] args) {

        Map<String, Expression> mapValue = new HashMap<>();

        mapValue.put("START", new Number(42));
        String x = "C";

        mapValue.put("A", new Combination(    new Reference("B"), new Number(-7)));
        mapValue.put("B", new Combination(new Reference("START"), new Number(+18)));
        mapValue.put("C", new Combination(    new Reference("A"), new Number(+25)));

        int result = 0;
        ArrayList<Expression> parts = new ArrayList<>();
        parts.add(mapValue.get(x));
        while (!parts.isEmpty()) {

            debuggingOutput(x, result, parts);

            Expression expression = parts.remove(0);
            if (expression instanceof Combination)
                parts.addAll(Arrays.asList(((Combination) expression).values));
            else if (expression instanceof Reference)
                parts.add(mapValue.get(((Reference) expression).reference));
            else if (expression instanceof Number)
                result += ((Number) expression).value;
        }
        System.out.println(result);
    }

    private static void debuggingOutput(String x, int result, ArrayList<Expression> parts) {
        System.out.print(x);
        System.out.print(" = ");
        System.out.print(result);
        for (Expression part : parts) {
            System.out.print(" + ");
            System.out.print(part);
        }
        System.out.println();
    }

}