나의 풀이

  function solution(str1, str2) {
            let answer = "YES";
            let sH = new Map();
            let sH2 = new Map();
            for (let x of str1) {
                if (sH.has(x)) sH.set(x, sH.get(x) + 1);
                else sH.set(x, 1);
            }
            // let max = Number.MIN_SAFE_INTEGER;

            for (let x of str2) {
                if (sH2.has(x)) sH2.set(x, sH2.get(x) + 1);
                else sH2.set(x, 1);

            }

            for (let [key, val] of sH) {
                if (key && val) {
                }
                //
                for (let [key, val] of sH) {
                    if (val == max) {
                        answer;
                        // max = val;
                        // answer = key;
                    } else {
                        answer = "False"
                    }
                }
                retu
                return answer;
            }
        }

        let a = "AbaAeCe";
        let b = "baeeACA";
        console.log(solution(a, b));

모범 답안

 

 

  • 객체 – 키가 있는 컬렉션을 저장함
  • 배열 – 순서가 있는 컬렉션을 저장함

등장배경

 

하지만 현실 세계를 반영하기엔 이 두 자료구조 만으론 부족해서 맵(Map)과 셋(Set)이 등장하게 되었습니다.

Map

맵(Map)은 키가 있는 데이터를 저장한다는 점에서 객체와 유사합니다. 다만, 맵은 키에 다양한 자료형을 허용한다는 점에서 차이가 있습니다.

맵에는 다음과 같은 주요 메서드와 프로퍼티가 있습니다.

  • new Map() – 맵을 만듭니다.
  • map.set(key, value)  key를 이용해 value를 저장합니다.
  • map.get(key)  key에 해당하는 값을 반환합니다. key가 존재하지 않으면 undefined를 반환합니다.
  • map.has(key)  key가 존재하면 true, 존재하지 않으면 false를 반환합니다.
  • map.delete(key)  key에 해당하는 값을 삭제합니다.
  • map.clear() – 맵 안의 모든 요소를 제거합니다.
  • map.size – 요소의 개수를 반환합니다.

 

참고> 

https://ko.javascript.info/map-set

 

맵과 셋

 

ko.javascript.info

 

'Front-End > JavaScript' 카테고리의 다른 글

js 인강필기  (0) 2023.12.09
[JavaScript] startsWith() / endsWith() 차이  (0) 2023.12.08
[JavaScript] 문자열을 합치는방법  (2) 2023.12.07
[Javascript] filter 사용법 예제  (2) 2023.12.03
[JavaScript] 문자열 변환방법  (0) 2023.12.01

나의 풀이

 function solution(k, arr) {
            let answer, sum = 0;
            let max = 0;
            // let Max = Number.MIN_SAFE_INTEGER;
            for (let i = 0; i < arr.length; i++) {
                // if (sum = arr[i] + arr[i + 1] + arr[i + 2] > Max)
                sum[i] = arr[i] + arr[i + 1] + arr[i + 2]
                if (sum[i + 1] >= sum[i]) {
                    max = sum[i + 1]
                    console.log(max)
                } else {
                    max = sum[i]
                }
                // let MAX = Math.max(sum);

            }
            return max;
        }

        let a = [12, 15, 11, 20, 25, 10, 20, 19, 13, 15];
        console.log(solution(3, a));

 

모범 답안

 

나의 풀이 

   function solution(m, arr) {
            let answer = 0, lt = 0, sum = 0;
            for (let lt = 0; lt < arr.length; lt++) {
                if (arr[lt] <= m) answer++;
            }
            for (let rt = 0; rt < arr.length; rt++) {
                sum += arr[rt];
                console.log('sum=?' + sum)
                if (sum <= m) answer++;
                while (sum > m) {
                    sum -= arr[lt++];
                    if (sum <= m) answer++;
                }
            }
            return answer;
        }


 // 1, 3 ,1 // 1 3,  3 1  //  1 1

        let a = [1, 3, 1];
        console.log(solution(5, a));
    </script>

나는 위와같이 풀었는데 위와같이 풀어도 코드가 잘 돌아가는것을 확인할수있다.

 

모범 답안

          function solution(m, arr){
                let answer=0, sum=0, lt=0;
                for(let rt=0; rt<arr.length; rt++){
                    sum+=arr[rt];
                    while(sum>m){
                        sum-=arr[lt++];
                    }
                    answer+=(rt-lt+1);
                }               
                return answer;
            }
            
            let a=[1, 3, 1, 2, 3];
            console.log(solution(5, a));

핵심 포인트1) answer += (rt-lt+1); 를 작성하는것이 핵심  ( 하나부터 경우의수를 3개만 작성해도 규칙을 알수있다)

2) while 문안에서 특정 조건동안 계속 반복되게 사용

 

나의 풀이

    function solution(m, arr) {
            let answer = 0, lt = 0, sum = 0;
            let len = a.length;
            let p1 = 0;

            for (let i = 0; i < a.length; i++) {
                (sum += arr[i])
                if (sum == m) {
                    sum += arr[i + 1]
                    answer++;
                } else if (sum > m) {
                    sum += arr[i + 1]
                }
            }


            return answer;
        }

        let a = [1, 2, 1, 3, 1, 1, 1, 2];
        console.log(solution(6, a));

모범 답안

 

나의 풀이 

 function solution(arr1, arr2) {
            let answer = [];
            let n = arr1.length;
            let m = arr2.length;
            let p1 = p2 = 0;

            // for (let i = 0; i < n; i++) {
            //     if (arr1[i].includes(arr2)) {
            //         answer.push(arr[i])
            //     }
            // }
            let newArr1 = arr1.sort((a, b) => a - b);
            let newArr2 = arr2.sort((a, b) => a - b);
            console.log(newArr1)
            console.log(newArr2)
            

            while (p1 < n && p2 < m) {
                // console.log(newArr2[p2])
                if (newArr1[p1] < newArr2[p2]) newArr1[p1++];
                else if (newArr1[p1] = newArr2[p2]) {
                    answer.push(newArr2[p2])
                } else {
                    newArr2[p2++];
                }
            }
            return answer;
        }

        let a = [1, 3, 9, 5, 2];
        let b = [3, 2, 5, 7, 8];
        console.log(solution(a, b));

우선 나는 위처럼 풀었는데 invalid array length 로 오류가 나왔었다.

좀 더 원인을 알아보니 newArr1[p1++] 이런부분을 그냥 p1++이런식으로 작성해야 했었다.

풀이식은 정답과 거의 유사

 

모범 답안

  function solution(arr1, arr2){
                let answer=[];
                arr1.sort((a, b)=>a-b);
                arr2.sort((a, b)=>a-b);
                let p1=p2=0;
                while(p1<arr1.length && p2<arr2.length){
                    if(arr1[p1]==arr2[p2]){
                        answer.push(arr1[p1++]);
                        p2++;
                    }
                    else if(arr1[p1]<arr2[p2]) p1++;
                    else p2++;
                }              
                return answer;
            }
            
            let a=[1, 3, 9, 5, 2];
            let b=[3, 2, 5, 7, 8];
            console.log(solution(a, b));

풀이 포인트1) p2++ 처럼 p2도 같이 증가해줘야 한다는점

2) sort는 문자열로 나오게 함으로서 2자리이상의 숫자일때 sort에 조건을 안적어주면 1 10 2 이런식으로 오름차순을해도 잘 출력이 잘되지않을수 있음으로 조건을 적어주자 

3) arr1[p1++] 이렇게 적어서 p1포함해서 ++ 해준다.

나의 풀이

    function solution(arr1, arr2) {
            let answer = [];
            let newArr = arr1.concat(arr2);
            newArr.sort()
            console.log(newArr)
            return answer;
        }

        let a = [1, 3, 5];
        let b = [2, 3, 6, 7, 9];
        console.log(solution(a, b));

 

이렇게 풀었는데 해설에서는 sort 는 nlogn 시간복잡도를 가진다고하고 

투 포인터 알고리즘을 사용하면 n +m 시간복잡도를 가져서 푼다고한다. 

 

   function solution(arr1, arr2) {
            let answer = [];
     
            for (let j = 0; j < a.length; j++) {
                for (let k = 0; k < b.length; k++) {
                    if (a[j] > b[k]) {
                        answer.push(b[k])
                    } else if (a[j] < b[k]) {
                        answer.push(a[j])
                    }
                }
            }
            console.log(answer)
            for (let i = b.length - a.legth; i < b.length; i++) {
                answer.push(b)
            }
            return answer;
        }

        let a = [1, 3, 5];
        let b = [2, 3, 6, 7, 9];
        console.log(solution(a, b));

두번째 풀이로 위처럼 해봤지만 잘 안되었었고 판단 미스가 있었는데 

경우의 수가 다 돌고나서 나머지 경우의 수를 2가지로 나눠줘야하는데 나는 1개만 나눠줬었다.

모범 답안

   function solution(arr1, arr2){
                let answer=[];
                let n=arr1.length;
                let m=arr2.length;
                let p1=p2=0;
                while(p1<n && p2<m){
                    if(arr1[p1]<=arr2[p2]) answer.push(arr1[p1++]);
                    else answer.push(arr2[p2++]);
                }
                while(p1<n) answer.push(arr1[p1++]);
                while(p2<m) answer.push(arr2[p2++]); 
                return answer;
            }
            
            let a=[1, 3, 5];
            let b=[2, 3, 6, 7, 9];
            console.log(solution(a, b));

풀이 핵심 포인트 1) p1=p2=0 으로 지정

2) 경우의수가 끝나고 남을경우 2개로 지정해서 따로 각각 써줘야한다는점

3) while() 안에 &&가 있으면 둘중하나가 거짓이 되면 끝난다 ( 이유는 and 연산자 이기때문 )

나의 풀이

 function solution(n, k, card) {
            let answer;
            // let max = Number.MIN_SAFE_INTEGER;
            let Max = Math.max(...arr);
            console.log('Max=?' + Max)
            let newArr = [];
            let upmax = arr.sort();
            console.log('upmax?' + upmax)
            for (let i = 0; i < arr.length; i++) {
                for (let j = 1; j < k; j++) {
                    newArr.push(upmax)
                    upmax.pop()
                    console.log(upmax)
                }
            }
            console.log('newArr=?' + newArr);
            return answer;
        }

        let arr = [13, 15, 34, 23, 45, 65, 33, 11, 26, 42];

        console.log(solution(10, 3, arr));

모범 답안

 function solution(n, k, card){
                let answer;
                let tmp = new Set();
                for(let i=0; i<n; i++){
                    for(let j=i+1; j<n; j++){
                        for(let k=j+1; k<n; k++){
                            tmp.add(card[i]+card[j]+card[k]);
                        }
                    }
                }
                let a=Array.from(tmp).sort((a, b)=>b-a);
                answer=a[k-1];
                return answer;
            }
            
            let arr=[13, 15, 34, 23, 45, 65, 33, 11, 26, 42];
            console.log(solution(10, 3, arr));

 

 

핵심 포인트 1) 문제에 3개 더한값? 이라고 나오면  => 3중 for문 떠올르는 아이디어 필요

2) set은 중복제거를 위해 사용하고, set은 sort를 못쓰니 array.from 으로 배열 만들고 sort 사용해서 내림차순으로 만들기 

3) 모범답안 풀이에 <n; 이렇게 범위 설정했는데 n-2로 하면 더 정확하게 표현되지만 어차피 돌면서 걸러지기에 n으로 범위 설정해도 괜찮은점

 

+ Recent posts