프로그래머스[JS] > 괄호 변환 ( 2020 KAKAO BLIND RECRUITMENT )

🔥문제링크

https://school.programmers.co.kr/learn/courses/30/lessons/60058

프로그래머스

 

🔥풀이

이 문제는 재귀함수를 이용하여 주어진 변환을 지속적으로 할 수 있는지를 확인하는 문제이다. 

재귀 함수를 진행하기 위해 필요한 함수 두개를( 균형잡힌 괄호 문자열인지 판단 하는 함수 => is_balanced_string, 올바른 괄호 문자열인지 판단하는 함수 =>is_right_string ) 정의하고 이를 재귀함수 내부에서 이용하여 분기처리 했다.

function solution(p) {
    const is_balanced_string=(str)=>{
        let [open_flag,close_flag]=[0,0]
        let str_arr = str.split('')
        str_arr.forEach((cha)=>{
            if(cha==='('){
                open_flag+=1
            }else{
                close_flag+=1
            }
        })
        return open_flag===close_flag 
    }
    
    const is_right_string=(str)=>{
        let arr =[]
        let str_arr = [...str]
        
        for(const cha of str_arr){
            if(cha==='('){
                arr.push('(')
            }else if(cha===')'){
                if(arr.at(-1) && arr.at(-1) === '('){
                    arr.pop()
                }else{
                    arr.push(')')
                    break;
                }
            }
        }
        return arr.length===0
    }
    
    // 빈 문자열인 경우 
    if(p.length===0) return p
    // 올바른 문자열인 경우
    if(is_right_string(p)) return p
    
    let answer =''
    
    const recursive=(str)=>{
        if(!str || str===''){
            return 
        }
        if(is_right_string(str)){
            answer+=str
            return
        }
        
        let str_arr= str.split('')
        let u=''
        let v=''
        
        while(1){
            let cha = str_arr.shift()
            if(!cha){ break;}
            u+=cha
            
            if(is_balanced_string(u)){
                if(is_right_string(u)){
                    answer+=u
                    let v=str_arr.join('') // '' 일 수 있음
                    recursive(v)
                    break;
                }else{
                    let new_arr = [...u]
                    let v=str_arr.join('')
                    answer+='('
                    recursive(v)
                    answer+=')'
                    
                    new_arr.shift()
                    new_arr.pop()
                    new_arr=new_arr.map((cha)=>{
                        return cha==='(' ? ')': '('
                    })
                    let reversed_string=new_arr.join('')
                    answer+=reversed_string
                    break;
                }
            }
        }
    }
    
    recursive(p)
    return answer;
}