[JS] 수식 최대화

완전탐색과 배열을 다루는 고차함수들을 활용해서 해결했다.

 

 

1.  최대 6가지 경우의 수가 나오니 각각의 우선순위대로 계산한 후에 최대값들을 저장할 배열을 생성

2. 정규표현식을 통해서 연산자 부분과 숫자 부분을 분리

3. eval함수를 쓸까 계산함수를 만들까 고민하다가 그냥 사칙연산을 해주는 간단한 함수를 생성

4. 6가지 경우의 수를 한번씩 순회

5. 각 연산자별로 순회 (ex.*+- => * , + , - 순서대로 3번 계산)

 

연산자들 중에서 이번 순서에 계산할 연산자를 구한 이후, 배열에서 삭제해가면서 정리

 

 

tmpNum [ 100, 60000, 500, 20 ]
operatorInfo [ 0 ]
tmpNum [ 100, 60000, 520 ]
operatorInfo [ 1 ]
tmpNum [ -59900, 520 ]
operatorInfo [ -1, 0 ]
tmpNum [ -60420 ]

내가 만든 코드에선 위처럼 동작하게 된다.

 

즉 , 숫자는 바로바로 배열에서 계산된 값을 저장해주며 연산자는 계산이 다 끝난 이후 filter을 통해서 한번에 없애준다.

 

조금 생각할점은 같은 연산자가 2번 연속 나오는 경우인데, 합쳐진 수에 이어서 계산을 해야하기 때문에 i에 1을 빼줘서 같은 부분을 한번 더 계산하게 한다.

 

 

 

 

 

function solution(expression) {
    const operatorOrderLst = ['*+-' , '*-+' , '+-*' , '+*-' , '-+*' , '-*+']
    
    const numLst = expression.match(/[^-*+]+/g).map(v => +v)
    const operatorLst = expression.match(/[-*+]/g)
    
    const calculate = (a,b,op) => {
        switch(op) {
            case '*':
                return a*b
            case '-':
                return a-b
            case '+':
                return a+b
        }
    }
    
    let ret = 0
    for (const operatorOrder of operatorOrderLst) {
        
        let tmpNum = [...numLst]
        let tmpOperator = [...operatorLst]
        
        for ( const operator of operatorOrder){
            
            let operatorInfo = tmpOperator.map((v,idx) => v===operator ? idx : null).filter(v => v!==null)
            
            for (let i = 0 ; i < tmpNum.length ; i++) {
                if (operatorInfo.includes(i)) {
                    tmpNum[i] = calculate(tmpNum[i],tmpNum[i+1],operator)
                    tmpNum = tmpNum.filter((v,idx) => idx!==i+1)
                    operatorInfo = operatorInfo.map(v => v-1)
                    i--
                }
            }
            
            
            tmpOperator = tmpOperator.filter(v => v!== operator)
        }
        
        
        ret = Math.max(ret , Math.abs(tmpNum[0]))
    }
    
    return ret
}