solution

function solution(X, Y) {    
    let ans = [];
    let stack = [];
    
    for(let i = 0; i < X.length; i++){
        if(stack.includes(X[i])){
            continue;
        }
        
        const yArr = Y.split(X[i]);
        
        if(yArr.length !== 1){
            const xArr = X.split(X[i]);
            
            const min = Math.min(xArr.length - 1, yArr.length - 1);
            
            ans.push(X[i].repeat(min));
        }
        
        stack.push(X[i]);
    }
    
    if(ans.length === 0){
        return "-1";
    }
    
    if(Number(ans.join("")) === 0){
        return "0";
    }
    
    ans = ans.join("").split("").sort((a,b) => b - a);
    
    return ans.join("");
}

풀리긴한다. 단, 시간은 최대 1744.49ms, 메모리는 최대 217MB까지 잡아먹게 되는 방법이다.
시간을 줄일 수 있는 방법은...X, Y에서 겹치는 숫자를 뽑는 방법을 다르게 해보면 될 것 같다.
현재는 한번 연산이 진행된 숫자는 stack에 넣어서 다음 연산에서 그대로 넘어가게 해놨는데,
모든 숫자를 일일이 검사하다보니 연산이 길어지는 것 같다.
최대 3,000,000의 길이를 가지는 입력값이 주어지기 때문에, 이 부분은 확실히 개선할 필요가 있다.

다른 분 풀이 참고 후 solution

function solution(X,Y){
    let countX = new Array(10).fill(0);
    const xArr = X.split("");
    
    xArr.forEach((item) => {
        countX[item]++;
    })
    
    let countY = new Array(10).fill(0);
    const yArr = Y.split("");
    
    yArr.forEach((item) => {
        countY[item]++;
    })
    
    let ans = [];
    
    countX.forEach((item, index) => {
        if(item !== 0 && countY[index] !== 0){
            const min = Math.min(item, countY[index]);
            
            ans.push(String(index).repeat(min));
        }
    })
    
    if(ans.length === 0){
        return "-1";
    }
    
    if(Number(ans.join("")) === 0){
        return "0";
    }
    
    return ans.reverse().join("");
}

0부터 9까지의 숫자를 배열로 만들고, 해당 숫자가 존재하면 그 인덱스의 카운트를 증가시킨다.
X, Y 모두 카운트가 0이 아닌 숫자가 있다면, 둘 중 더 작은 카운트를 선택해서 사용한다.
0부터 시작해서 숫자를 작은 카운트만큼 repeat()해서 ans 배열에 저장한 뒤,
reverse()하고 join()하면 만들 수 있는 가장 큰 수가 나온다.

개선 결과, 시간은 최대 244.89ms, 메모리는 최대 103MB까지 줄일 수 있었다.

참고 자료

huimang2님 블로그