수식 최대화

Java

import java.util.*;
import java.lang.*;
class Solution {
    List<String[]> list;
    public long solution(String expression) {
        list = new ArrayList<>();
        List<String> operator = new ArrayList<>();
        operator.add("*");operator.add("+");operator.add("-");
        makeOrderList(operator, new ArrayList<>());//*+- 순열 조합 완료
        long answer = 0;
        for(int i = 0; i < list.size(); i++){//연산 순서
            String exp1 = expression;
            for(int o = 0; o < list.get(i).length; o++){
                exp1 = operatorMethod(exp1, list.get(i)[o]);
                if(isNumber(exp1)) break;
            }
            
            if(Math.abs(Long.parseLong(exp1)) > answer) answer = Math.abs(Long.parseLong(exp1));
        }
        
        return answer;
    }
    
    private void makeOrderList(List<String> operator, List<String> ordered){
        if(operator.size() == 1){
            
            ordered.add(operator.get(0));
            String[] str = new String[ordered.size()];
            for(int i = 0; i < str.length; i++)
                str[i] = ordered.get(i);
            list.add(str);
            return;
        }
        
        for(int i = 0; i < operator.size(); i++){
            List<String> copy = new ArrayList<>(ordered);
            List<String> copyOper = new ArrayList<>(operator);
            copy.add(operator.get(i));
            copyOper.remove(i);
            makeOrderList(copyOper, copy);
        }
    }
    
    private String operatorMethod(String str, String operator){
        String[] splitStr = str.split("\\" + operator);
        String result = "";
        if(splitStr.length == 1) return str;
        
        for(int i = 0; i < splitStr.length - 1; i++){
            long before = 0;
            long after = 0;
            for(int f = splitStr[i].length() - 1; f >= 0; f--){
                if(f == 0){
                    before = Long.parseLong(splitStr[i]);
                    splitStr[i] = "";
                    break;
                }
                if(!isNumber(splitStr[i].substring(f, f + 1))){
                	if(((f - 1 >= 0 && !isNumber(splitStr[i].substring(f - 1, f))) || f == 0)
                		&& (i > 0 && !isNumber(splitStr[i - 1]))){//음수일 때
                		f = f - 1;
                	}
                    before = Long.parseLong(splitStr[i].substring(f + 1, splitStr[i].length()));
                    splitStr[i] = splitStr[i].substring(0, f + 1);
                    break;
                }
            }
            for(int f = 0; f < splitStr[i + 1].length(); f++){
                if((f == splitStr[i + 1].length() - 1 && isNumber(splitStr[i + 1].substring(f, f + 1)))
                	&& (!isNumber(splitStr[i]))){
                    after = Long.parseLong(splitStr[i + 1]);
                    splitStr[i + 1] = numberOperator(before, after, operator);
                    break;
                }
                if(!isNumber(splitStr[i + 1].substring(f, f + 1)) && f != 0){
                    after = Long.parseLong(splitStr[i + 1].substring(0, f));
                    splitStr[i + 1] = numberOperator(before, after, operator) + splitStr[i + 1].substring(f, splitStr[i + 1].length());
                    break;
                }
            }
            
            result += splitStr[i];
            
        }
        result += splitStr[splitStr.length - 1];
        return result;
    }
    
    private boolean isNumber(String number){
        try{
            Long.parseLong(number);
            return true;
        }catch(Exception e){
            return false;
        }
    }
    
    private String numberOperator(long before, long after, String operator){
        switch(operator){
            case "*": return String.valueOf(before * after);
            case "+": return String.valueOf(before + after);
            case "-": return String.valueOf(before - after);
        }
        return "";
    }
}

Python

import itertools
def solution(expression):
    answer = 0
    operator = ("*", "+", "-")
    operatorList = list(itertools.permutations(operator))
    
    for i in range(len(operatorList)):
        exp1 = expression
        for o in range(len(operatorList[i])):
            exp1 = operatorMethod(exp1, operatorList[i][o])
            
            if exp1.isdigit(): break
        
        if abs(int(exp1)) > answer: answer = abs(int(exp1))
        
    return answer

def operatorMethod(string, operator):
    splitStr = string.split(operator)
    result = ""
    if len(splitStr) == 1: return string
    
    for i in range(0, len(splitStr) - 1):
        before, after = 0, 0
        for f in range(len(splitStr[i]) - 1, 0 - 1, -1):
            if f == 0:
                before = int(splitStr[i])
                splitStr[i] = ""
                break
            if not splitStr[i][f:f + 1].isdigit():
                if ((f - 1 >= 0 and (not splitStr[i][f - 1:f].isdigit()) or f == 0) and (i > 0 and (not splitStr[i - 1].isdigit()))):
                    f = f - 1
                before = int(splitStr[i][f + 1:]);
                splitStr[i] = splitStr[i][0:f + 1]
                break
    
        for f in range(0, len(splitStr[i + 1])):
            if (f == len(splitStr[i + 1]) - 1 and splitStr[i + 1][f:f + 1].isdigit()) and not splitStr[i].isdigit():
                after = int(splitStr[i + 1])
                splitStr[i + 1] = numberOperator(before, after, operator)
                break
            if (not splitStr[i + 1][f:f + 1].isdigit()) and f != 0:
                after = int(splitStr[i + 1][0:f])
                splitStr[i + 1] = numberOperator(before, after, operator) + splitStr[i + 1][f:]
                break
                
        result += splitStr[i]
    
    result += splitStr[-1]
    return result


def numberOperator(before, after, operator):
    if operator == "*": return str(before * after)
    if operator == "+": return str(before + after)
    if operator == "-": return str(before - after)