CODE_PLAN

나의 풀이 

우선 나는 이런식을 풀려고했고 문제 구상및 이해는 다 되었었다.

근데 이걸 코드로 구현하는게 아직 미흡해서 제한시간이 지난후 답을 보게되었다.

모범 정답

풀이 핵심 1)        if(j!==i && (product[j][0]+product[j][1])>money) break;   

위 코드는 money보다 금액이 클경우를 막아주기 위한 코드로서 적어야 쓸데없는 동작을 안한다.

2) sort에서 나는 a,b만 적어주고 식이 없었는데 (a[0]+a[1])-(b[0]+b[1]) 이런식으로 구체적으로 적어줘야 값이 잘 정렬된다.

나의 풀이

function solution(test) {
            let answer, cnt = 0;
            let add = [];

            for (let i = 0; i < arr.length; i++) {
                for (let j = 0; j < arr[0].length; j++) {
                    if (add.push(arr[i][0]) && add.push(arr[i][1])) {
                        console.log('add?' + add);
                    }

                    if (arr[i][j] &&) {

                    }
                    // arr[i][0]


                }
            }
            return answer;
        }

        let arr = [[3, 4, 1, 2], [4, 3, 2, 1], [3, 1, 4, 2]];
        console.log(solution(arr));

여담이지만 코테는 정말 컨디션이 좋을때 풀어야 잘 풀리는것 같다.. 아직 코테 초보라 그런지 어렵다ㅎㅎ

모범 답안

<script>
            function solution(test){
                let answer=0;
                m=test.length;
                n=test[0].length;
                for(let i=1; i<=n; i++){
                    for(let j=1; j<=n; j++){
                        let cnt=0;
                        for(let k=0; k<m; k++){
                            let pi=pj=0;
                            for(let s=0; s<n; s++){
                                if(test[k][s]===i) pi=s;
                                if(test[k][s]===j) pj=s;
                            }
                            if(pi<pj) cnt++;
                        }
                        if(cnt===m) answer++;
                    }
                }
                return answer;
            }
            
            let arr=[[3, 4, 1, 2], [4, 3, 2, 1], [3, 1, 4, 2]];
            console.log(solution(arr));
 </script>

나의 풀이

function solution(arr) {
            let answer = [];
            answer == arr.reverse();
            answer = answer.filter((arr) => {
                // n 을 나누어 0이 되는 수를 담을 배열
                let a = [];
                for (let i = 2; i < n + 1; i++) {
                    n % i === 0 && a.push(i);
                }   
                // 나누어 0이되는 수가 자기자신과 1이면 소수
                // 2부터 시작했으므로 1은 제외하고 자기자신으로 나눠지면 반환
                return a[0] === arr ? true : false;
            });
            // for (let x of s) {
            //     if () {
            //         // 나눈게  1, 자기자신 
            //     }
            // }
            return answer;
        }


        let arr = [32, 55, 62, 20, 250, 370, 200, 30, 100];
        console.log(solution(arr));
    </script>

우선 뒤집는거랑 소수를 구현하는데 애썼다.. 

해설 정답 

<script>
            function isPrime(num){
                if(num===1) return false;
                for(let i=2; i<=parseInt(Math.sqrt(num)); i++){
                    if(num%i===0) return false;
                }
                return true;
            }
            function solution(arr){
                let answer=[];
                for(let x of arr){
                    let res=0;
                    while(x){
                        let t=x%10;
                        res=res*10+t;
                        x=parseInt(x/10);
                    }
                    if(isPrime(res)) answer.push(res);
                }
                return answer;
            }
            
            let arr=[32, 55, 62, 20, 250, 370, 200, 30, 100];
            console.log(solution(arr));
        </script>

풀이 포인트 1) while문 안의 뒤집는 방법에 대해서 익숙해야함

풀이 포인트2) 함수 하나를 하나더 만들어서 num === 1  이뜻은 즉, 소수인경우인데 이경우는 빼고 하는거다

밑에는 나누어떨어지는 즉, 약수가 존재할때 조건을 달아준것

나의 풀이

  function solution(s) {
            let answer = "";
            let len = str.length;
            let num = 0;

            for (let x of s) {
                if (str[x].indexOf(str[x]))
                    if (str[i] == str[i + 1]) {
                        num++;
                        answer.push(num)
                    }
                if (str[x] == str[x + 1]) {
                    num++
                } else {
                    
                }
            }
            return answer;
        }

        let str = "KKHSSSSSSSE";
        console.log(solution(str));
    </script>

해설지 풀이

     <script>
            function solution(s){
                let answer="";
                let cnt=1;
                s=s+" ";
                for(let i=0; i<s.length-1; i++){
                    if(s[i]===s[i+1]) cnt++;
                    else{
                        answer+=s[i];
                        if(cnt>1) answer+=String(cnt);
                        cnt=1;
                    }
                }
                return answer;
            }
            
            let str="KKHSSSSSSSE";
            console.log(solution(str));
        </script>

나의 풀이

    function solution(s, t) {
            let answer = [];
            if(Math.sqrt((s-t)))
            
            if()


            return answer;
        }
        
        let str = "teachermode";
        console.log(solution(str, 'e'));
    </script>

해설 풀이

  <script>
            function solution(s, t){
                let answer=[];
                let p=1000;
                for(let x of s){
                    if(x===t){
                        p=0;
                        answer.push(p);
                    }
                    else{
                        p++;
                        answer.push(p);
                    }
                }
                p=1000;
                for(let i=s.length-1; i>=0; i--){
                    if(s[i]===t) p=0;
                    else{
                        p++;
                        answer[i]=Math.min(answer[i], p);
                    }
                }
                return answer;
            }
            
            let str="teachermode";
            console.log(solution(str, 'e'));
        </script>

나의 풀이 1)

 function solution(str) {
            let answer = "";
            str = str.replaceAll("[^0-9]", '');
            // console.log(str)
            return str ;
        }
        let str = "g0en2T0s8eSoft";
        console.log(solution(str));
</script>

나의 풀이는 replaceAll을 이용해서 0-9 숫자가 아닌것은 모두 ' ' 빈문자열로 만들고 나머지 str을 출력하는것인데 출력이 잘 안되었었다

수정후 풀이2) 

   function solution(str) {
            let answer = "";
            str = str.replaceAll(/[^0-9]/g, '');
            // console.log(str)
            return str;
        }
        let str = "g0en2T0s8eSoft";
        console.log(solution(str));
    </script>

replaceAll 부분의 안 내용부분을 /[^0-9]/g 이렇게 수정해주니까 풀렸다.. replaceAlll 의 문법공부의 필요성!.

해설 정답풀이

<script>
            function solution(str){
                let answer="";
                for(let x of str){
                    if(!isNaN(x)) answer+=x;
                }  
                return parseInt(answer);
            }
            
            let str="g0en2T0s8eSoft";
            console.log(solution(str));
</script>

풀이 포인트1) isNaN을 사용해서 숫자인지 아닌지를 판별
- isNaN 은 true 일때 숫자가 아닌거고 false 일때 숫자인것 

풀이 포인트2) parseInt로 출력된 ex) 000234 이렇게 되어있으면 parseInt로 000를 없애주고 234로 출력한다.

+ tip) 손 코딩 문제가 나올수있으니 예를들면 parseInt 를 사용하지마라 이렇게 제시가 왔을때는 Number를 사용해서 풀어보기도하고 준비해야될것 같다.

나의 풀이 

function solution(s) {
            let a = s.slice(0, (s.length / 2))
            let b = s.slice(-s.length, (s.length / 2))
            console.log(s.slice(-s.length))
            console.log(a)
            console.log(b)
            // let bigstr = s.toUpperCase()
            if (a === b) {
                return "YES"
            } else {
                return "NO"
            }

            return s;
        }

        let str = "gooG";
        console.log(solution(str));

위는 나의 풀이인데 정답이 잘 나오지 않았던게 아쉬웠다.

아쉽게 안된것같은데 좀 더 여러가지 풀이법을 찾아봐야겠다

정답 풀이

 <script>
            function solution(s){
                let answer="YES";
                s=s.toLowerCase();
                let len=s.length;
                for(let i=0; i<Math.floor(len/2); i++){
                    if(s[i]!=s[len-i-1]) return "NO";
                }
                return answer;
            }
            
            let str="goooG";
            console.log(solution(str));
</script>

여기서 핵심1)  s[len-i-1] 이부분 이것을 잘 기억해둬야 잘 쓸수있을것 같다.

나의 풀이

    function solution(arr) {
            let n = arr.length;
            let num = 0;
            for (let i = 0; i < n; i++) {
                for (let j = 0; j < n; j++) {
                    if (arr[i][j] > arr[i][j + 1]) {
                        num++;
                    }
                }
            }
            return num;
        }

        if (arr[i][j] > arr[i + 1][j]) {
            num++;
        }
        // 
        let 
         arr = [[5, 3, 7, 2, 3],
        [3, 7, 1, 6, 1],
        [7, 2, 5, 3, 4],
        [4, 3, 6, 4, 1],
        [8, 7, 3, 5, 2]];
        console.log(solution(arr));
    </script>

우선 아직 알고리즘을 많이 안해봐서 그런지 풀이법이 잘 떠오르지 않았었다.

&& 를 사용해서 조건을 넣어주는것도 오류가 나와서 멘붕..

해설 풀이 

            function solution(arr){  
                let answer=0;
                let n=arr.length;
                let dx=[-1, 0, 1, 0];
                let dy=[0, 1, 0, -1];
                for(let i=0; i<n; i++){
                    for(let j=0; j<n; j++){
                        let flag=1;
                        for(let k=0; k<4; k++){
                            let nx=i+dx[k];
                            let ny=j+dy[k];
                            if(nx>=0 && nx<n && ny>=0 && ny<n && arr[nx][ny]>=arr[i][j]){
                                flag=0;
                                break;
                            }
                        }
                        if(flag) answer++;
                    }
                }  
                  
                return answer;
            }

            let arr=[[5, 3, 7, 2, 3], 
                     [3, 7, 1, 6, 1],
                     [7, 2, 5, 3, 4],
                     [4, 3, 6, 4, 1],
                     [8, 7, 3, 5, 2]];
            console.log(solution(arr));

풀이 핵심1) dx, dy를 잡고 let nx, ny를 사용해서 위치를 이동하면서 탐색하는것 

풀이 핵심2)  또한 밖으로 나가지 않게 >=0 , <n 이런식으로 범위를 설정해줘야한다