프로그래머스 2단계 답지2

스킬트리 -- Summer/Winter Coding(~2018)

function solution(skill, skill_trees) {
    let answer=0;
    let reg=new RegExp(`[${skill}]`);
    for(let i=0;i<skill_trees.length;i++){
        let index=0;
        for(let j=0;j<skill_trees[i].length;j++){
            if(skill_trees[i][j].match(reg)){
                if(skill_trees[i][j]===skill[index]) index++;
                else{
                    answer--;
                    break;
                }
            }
        }
        answer++;
    }
    return answer;
}

reg로 skill에 match되는 문자열을 찾고 그때 index를 비교하면 된다.

코드가 좀 길고 비효율적인 듯... 수정할거

programmers.co.kr/learn/courses/30/lessons/49993

 

멀쩡한 사각형 -- Summer/Winter Coding(2019)

function solution(w, h) {
    return w*h-(w+h-gcd(w,h));
}

function gcd(n1, n2) {
  return n1%n2 ? gcd(n2, n1%n2) : n2;
}

예제 그림에서 볼 때 높이 index가 w와 h의 최대공약수 일 때 정사각형을 덜 지나는 것을 알 수 있다.

이것을 가지고 최대공약수 1일때와 2일때 그림을 그려서 생각해보면 답을 알 수 있다.

programmers.co.kr/learn/courses/30/lessons/62048

 

문자열 압축 -- 2020 KAKAO BLIND RECRUITMENT

function solution(s) {
    let min=s.length;
    for(let i=1;i<=s.length/2;i++){
        let arr=[];
        for(let j=0;j<s.length;j+=i){
             arr.push(s.substr(j,i))
        }
        for(let k=0;k<arr.length;k++){
            if(arr[k]===arr[k+1]){
                if(typeof arr[k-1]==="number"){
                    arr[k-1]=arr[k-1]+1;
                    arr.splice(k+1,1);
                    k--;
                }
                else arr[k]=2;
            }
        }
        arr=arr.join('');
        if(min>arr.length) min=arr.length;
    }
    return min;
}

 

삼각 달팽이 -- 2020 KAKAO BLIND RECRUITMENT

function solution(n) {
    let arr=[];
    for(let i=1;i<=n;i++){
        arr.push(Array(i).fill(0));
    }
    let top=0, bottom=n-1, left=0, right=n-1, up_minus=0;
    let num=1;
    while(num<=n*(n+1)/2){
        //아래로 이동
        for(let i=top;i<=bottom;i++){
            arr[i][left]=num++;
        }
        top++;
        left++;
        // console.log("아래",arr,top,bottom,left,right);
        
        //오른쪽 이동
        for(let i=left;i<=right;i++){
            arr[bottom][i]=num++;
        }
        bottom--;
        right--;
        // console.log("오른쪽",arr,top,bottom,left,right);
        
        //위로 이동
        for(let i=bottom;i>=top;i--){
            arr[i][arr[i].length-1-up_minus]=num++;
        }
        right--;
        top++;
        up_minus++
        // console.log("위",arr,top,bottom,left,right);
        // console.log(top,bottom,left,right,arr);
    }
    // return arr.reduce((acc,cur)=>acc.concat(cur),[]);
    return arr.flat();
}

일반적인 달팽이 문제를 풀어봤으면 풀 수 있다. 2차원 배열을 하나의 배열로 합칠때 reduce말고 flat도 있다.

flat() 메서드는 모든 하위 배열 요소를 지정한 깊이까지 재귀적으로 이어붙인 새로운 배열을 생성합니다

programmers.co.kr/learn/courses/30/lessons/68645

 

괄호 변환 -- 2020 KAKAO BLIND RECRUITMENT

function solution(p) {
    if(!p) return ""
    let count=0;
    let correct=true;
    for(let i=0;i<p.length;i++){
        if(p[i]==="(") count++;
        else count--;
        if(count<0) correct=false;
        if(count===0){
            if(correct){
		return p.slice(0,i+1)+solution(p.slice(i+1,p.length));
            }else{
                let answer="("+solution(p.slice(i+1,p.length))+")";
                const u=p.slice(0,i+1);
                for(let j=1;j<u.length-1;j++){
                    answer+= u[j]==="(" ? ")" : "("
                }
                return answer;
            }
        }
    }
}

programmers.co.kr/learn/courses/30/lessons/60058

 

쿼드 압축 후 개수 세기

function solution(arr) {
    const len=arr.length;
    if(len===1) return arr[0];
    let answer=[0,0];
    const arr1=[], arr2=[], arr3=[], arr4=[];
    for(let i=0;i<len;i++){
        if(i<len/2){
            arr1.push(arr[i].slice(0,len/2));
            arr2.push(arr[i].slice(len/2));
        }else{
            arr3.push(arr[i].slice(0,len/2));
            arr4.push(arr[i].slice(len/2)); 
        }
    }
    const combine_arr=[arr1,arr2,arr3,arr4];
    // console.log(combine_arr);
    
    const sum_arr=[];
    for(let i=0;i<4;i++){
        sum_arr.push(combine_arr[i].map(i=>i.map(j=>j).reduce((acc,cur)=>acc+cur,0)).reduce((acc,cur)=>acc+cur,0));
    }
    // console.log(sum_arr);
    
    const sum=sum_arr.reduce((acc,cur)=>acc+cur,0)
    if(sum===0) return [1,0];
    if(sum===arr.length**2) return [0,1];
    // let zero=0;
    // let one=0;
    // for(let i=0;i<4;i++){
    //     if(sum_arr[i]===0){
    //         zero++;
    //     }else if(sum_arr[i]===(len/2)**2){
    //         one++;
    //     }
    // }
    // if(zero===4) return [1,0];
    // if(one===4) return [0,1];
    
    for(let i=0;i<4;i++){
        if(sum_arr[i]===0){
            answer[0]++;
        }else if(sum_arr[i]===(len/2)**2){
            answer[1]++;
        }else{
            const sol=solution(combine_arr[i]);
            answer[0]+=sol[0];
            answer[1]+=sol[1];
        }
    }
    return answer;
}

모두 0이거나 1인 경우를 생각을 못해서 테스트케이스 한 개를 틀렸었다. 주석대신 reduce 사용

programmers.co.kr/learn/courses/30/lessons/68936

 

튜플 -- 2019 카카오 개발자 겨울 인턴십

기본

function solution(s) {
    s=s.slice(2,s.length-2).split('},{');
    s.sort((a,b)=>a.length-b.length);
    let result=[];
    for(let i=0;i<s.length;i++){
        let arr=s[i].split(',');
        for(let j=0;j<arr.length;j++){
            if(result.indexOf(arr[j])===-1){
                result.push(arr[j]);
            }
        }
    }
    return result.map(i=>i*1);
}

간단  -- JSON.parse를 하지 않으면 "[~~~]"형태라서 객체로 만들어줘야 한다.

function solution(s) {
    s=JSON.parse(s.replace(/{/g, '[').replace(/}/g, ']'));
    s.sort((a,b)=>a.length-b.length);
    return s.reduce((acc,cur)=>
        acc.concat(cur.filter(val=>!acc.includes(val))),[])
}

 

문제가 쉬워서 그냥 풀면 나온다.

programmers.co.kr/learn/courses/30/lessons/64065

 

폰켓몬

function solution(nums) {
    const arr=[...new Set(nums)];
    return arr.length<nums.length/2 ? arr.length : nums.length/2;
}

set과 spread만 알고 있다면 간단히 해결

programmers.co.kr/learn/courses/30/lessons/1845

 

이진 변환 반복하기

기본

function solution(s) {
    let count=0, remove_zeros=0;
    binary_transform(s);
    function binary_transform(s){
        if(s==1) return;
        let binary_transform_1=s.split('').filter(val=>val==='1').join('');
        remove_zeros+=s.length-binary_transform_1.length;
        count++;
        binary_transform(binary_transform_1.length.toString(2));
    }
    return [count,remove_zeros];
}

간단

function solution(s) {
    let answer=[0,0];
    while(s!=='1'){
        answer[0]++;
        answer[1]+=(s.match(/0/g)||[]).length;
        s=s.replace(/0/g,'').length.toString(2);
    }
    return answer;
}

programmers.co.kr/learn/courses/30/lessons/70129

 

수식 최대화 -- 2020 카카오 인턴십

function solution(expression) {
  const num = expression
    .replace(/\+/g, ",")
    .replace(/\-/g, ",")
    .replace(/\*/g, ",")
    .split(",");
  const operation = expression.replace(/[0-9]/g, "").split("");
  const prior_operation = [
    ["*", "+", "-"],
    ["*", "-", "+"],
    ["+", "*", "-"],
    ["+", "-", "*"],
    ["-", "+", "*"],
    ["-", "*", "+"],
  ];

  let result = [];
  for (let i = 0; i < prior_operation.length; i++) {
    let num_slice = num.slice();
    let operation_slice = operation.slice();
    for (let j = 0; j < prior_operation[i].length; j++) {
      while (operation_slice.indexOf(prior_operation[i][j]) !== -1) {
        let idx = operation_slice.indexOf(prior_operation[i][j]);
        num_slice.splice(
          idx,
          2,
          calculate(num_slice[idx], num_slice[idx + 1], prior_operation[i][j])
        );
        operation_slice.splice(idx, 1);
      }
    }
    result.push(Math.abs(num_slice[0]));
  }
  return Math.max(...result);
}

function calculate(a, b, operation) {
  a = +a;
  b = +b;
  if (operation === "+") return a + b;
  else if (operation === "-") return a - b;
  else return a * b;
}

prior_operation을 수식이 최대 3개밖에 없으니 그냥 만들고 시작했다. 3개보다 적은 경우라도 상관없이 동작한다.

programmers.co.kr/learn/courses/30/lessons/67257

 

짝지어 제거하기

function solution(s){
    let arr=[];
    for(let i=0;i<s.length;i++){
        arr[arr.length-1]===s[i] ? arr.pop() : arr.push(s[i]);
    }
    return arr.length===0 ? 1 : 0;
}

스택으로 풀면 쉽다

programmers.co.kr/learn/courses/30/lessons/12973

 

소수 만들기 -- Summer/Winter Coding(~2018)

const getCombinations = (arr, selectNumber) => {
  const result = [];
  if (selectNumber === 1) return arr.map((i) => [i]); // 1개씩 선택한다면 모든 배열의 원소를 return한다.
  
  arr.forEach((fixed, index, array) => {
    const rest = array.slice(index + 1); // fixed의 다음 index 부터 끝까지의 배열(조합)
    const combinations = getCombinations(rest, selectNumber - 1); // rest에 대한 조합을 구한다.
    const attached = combinations.map((combination) => [fixed, ...combination]); // fixed와 rest에 대한 조합을 붙인다.
    result.push(...attached); // result 배열에 push
  });
  
  return result;
};

function isPrime(n){
    if(n<2) return false;
    for(let i=2;i<=n/2;i++){
        if(n%i===0){
            return false;
        }
    }
    return true;
}

function solution(nums) {
    const combi_arr=getCombinations(nums,3);
    const sum_arr=combi_arr.map(i=>i.reduce((acc,cur)=>acc+cur,0));
    return sum_arr.reduce((acc,cur)=>{
        if(isPrime(cur)) return acc+1;
        return acc;
    },0);
    // let ans=0;
    // for(let i=0;i<sum_arr.length;i++){
    //     if(isPrime(sum_arr[i])) ans++;
    // }
    // return ans;
}

 

조합으로 풀었다. 3개를 고정해서 선택하기 때문에 빨리 풀어야 한다면 조합을 짜지 않고 그냥 for문 3번 돌려도 된다.

programmers.co.kr/learn/courses/30/lessons/12977

 

점프와 순간 이동 -- Summer/Winter Coding(~2018)

function solution(n) {
    if(n===1 || n===2) return 1;
    let answer=1;
    while(n!==2){
        if(n%2===0){
            n/=2;
        }else{
            n-=1;
            answer++;
        }    
    }
    return answer;
}

n이 1, 2일때 조심

programmers.co.kr/learn/courses/30/lessons/12980

 

영어 끝말잇기 -- Summer/Winter Coding(~2018)

function solution(n, words) {
    for(let i=1;i<words.length;i++){
        if(words[i-1][words[i-1].length-1]!==words[i][0] || 
           words.slice(0,i).includes(words[i])
          ){
            return [i%n+1, Math.floor(i/n)+1]; 
        }
    }
    return [0,0];
}

쉬운문제

programmers.co.kr/learn/courses/30/lessons/12981

 

예상 대진표

function solution(n,a,b){
    let answer=0;
    while(a!==b){
        a=Math.ceil(a/2);
        b=Math.ceil(b/2);
        answer++;
    }
    return answer;
}

쉬운 문제

programmers.co.kr/learn/courses/30/lessons/12985

 

뉴스 클러스터링 -- 2018 KAKAO BLIND RECRUITMENT 

function solution(str1, str2) {
  const arr1 = textDivide(str1.toLowerCase());
  const arr2 = textDivide(str2.toLowerCase());
  // console.log(arr1, arr2);

  if (arr1.length === 0 && arr2.length === 0) return 65536;

  const set = new Set([...arr1, ...arr2]);
  // console.log(set);

  let union = 0;
  let intersection = 0;
  set.forEach((val) => {
    const contain_arr1 = arr1.filter((i) => i === val).length;
    const contain_arr2 = arr2.filter((i) => i === val).length;
    union += Math.max(contain_arr1, contain_arr2);
    intersection += Math.min(contain_arr1, contain_arr2);
  });
  return Math.floor((intersection / union) * 65536);
}

function textDivide(str) {
  const arr = [];
  for (let i = 0; i < str.length - 1; i++) {
    const text = str.substr(i, 2);
    if (text.match(/[a-zA-Z]{2}/)) {
      arr.push(text);
    }
  }
  return arr;
}

생각만 잘하면 어렵지 않은데 조금 헷갈릴 수 있다.

programmers.co.kr/learn/courses/30/lessons/17677

 

 

프렌즈4블록 -- 2018 KAKAO BLIND RECRUITMENT

function solution(m, n, board) {
  board = board.map((i) => i.split(""));
  while (true) {
    //지울 정사각형의 왼쪽 위 index 배열을 구하자
    let delete_index = [];
    for (let i = 0; i < m - 1; i++) {
      for (let j = 0; j < n - 1; j++) {
        const value = board[i][j];
        if (value === 0) continue;
        if (
          board[i + 1][j] === value &&
          board[i][j + 1] === value &&
          board[i + 1][j + 1] === value
        ) {
          delete_index.push([i, j]);
        }
      }
    }
    // console.log("delete_index", delete_index);

    //지울 블록이 없으면 break
    if (delete_index.length === 0) break;

    //board에서 존재하지 않는 행렬에 0대입
    for (let i = 0; i < delete_index.length; i++) {
      board[delete_index[i][0]][delete_index[i][1]] = 0;
      board[delete_index[i][0] + 1][delete_index[i][1]] = 0;
      board[delete_index[i][0]][delete_index[i][1] + 1] = 0;
      board[delete_index[i][0] + 1][delete_index[i][1] + 1] = 0;
    }
    // console.log("0대입 board", board);

    for (let i = m - 1; i >= 1; i--) {
      for (let j = 0; j < n; j++) {
        if (board[i][j] === 0) {
          let ii = i - 1;
          while (ii >= 0) {
            ii--;
            if (ii === -1) break;
            if (board[ii][j] !== 0) break;
          }
          const delete_length = i - ii;
          if (ii !== -1) {
            let iii = i;
            for (let k = 0; k < delete_length; k++) {
              if (iii - delete_length < 0) {
                for (iii; iii >= 0; iii--) {
                  board[iii][j] = 0;
                }
                break;
              } else {
                board[iii][j] = board[iii - delete_length][j];
                board[iii - delete_length][j] = 0;
              }
              iii--;
            }
          }
        }
      }
    }
  }
  let answer = 0;
  for (let i = 0; i < m; i++) {
    for (let j = 0; j < n; j++) {
      if (board[i][j] == 0) answer++;
    }
  }
  return answer;
}

 

매우 힘들게 풀었다.... 코드가 그래서 개판. 수정할것

programmers.co.kr/learn/courses/30/lessons/17679

 

캐시 -- 2018 KAKAO BLIND RECRUITMENT

function solution(cacheSize, cities) {
    if(cacheSize===0) return cities.length*5;
    let arr=[];
    return cities.reduce((acc,cur)=>acc+LRU(arr,cacheSize,cur.toLowerCase()),0);
}

function LRU(arr,casheSize,city){
    const idx=arr.indexOf(city);
    if(idx!==-1){
        arr.splice(idx,1);
        arr.push(city);
        return 1;
    }
    else{
        if(arr.length>=casheSize){
            arr.shift();
        }
        arr.push(city);
        return 5;
    }
}

쉽다.. 0인 예외만 생각한다면

programmers.co.kr/learn/courses/30/lessons/17680

 

오픈채팅방 -- 2019 KAKAO BLIND RECRUITMENT

function solution(record) {
    let users={};
    record.reverse();
    record.forEach(val=>{
        const rec=val.split(' ');
        if(rec[2] && !users[rec[1]]){
            users[rec[1]]=rec[2];
        }
    });
    record.reverse();
    let answer=[];
    record.forEach(val=>{
        const rec=val.split(' ');
        if(rec[0]==="Enter"){
            answer.push(`${users[rec[1]]}님이 들어왔습니다.`);
        }else if(rec[0]==="Leave"){
            answer.push(`${users[rec[1]]}님이 나갔습니다.`)
        }
    });
    return answer;
}

해시 테이블만 사용할줄 알면 풀 수 있다.

reverse를 하지 않으면 유저가 들어올때와 닉네님을 바꿀 때 모두 변경하면 된다. 

programmers.co.kr/learn/courses/30/lessons/42888

 

후보키 -- 2019 KAKAO BLIND RECRUITMENT

const getCombinations = (arr, selectNumber) => {
  const result = [];
  if (selectNumber === 1) return arr.map((i) => [i]); // 1개씩 선택한다면 모든 배열의 원소를 return한다.

  arr.forEach((fixed, index, array) => {
    const rest = array.slice(index + 1); // fixed의 다음 index 부터 끝까지의 배열(조합)
    const combinations = getCombinations(rest, selectNumber - 1); // rest에 대한 조합을 구한다.
    const attached = combinations.map((combination) => [fixed, ...combination]); // fixed와 rest에 대한 조합을 붙인다.
    result.push(...attached); // result 배열에 push
  });

  return result;
};

function solution(relation) {
  let candidate_key = [];

  //combination 배열을 만든다.
  const combi_for_arr = Array(relation[0].length)
    .fill()
    .map((i, idx) => idx);
  let combi = [];
  for (let i = 1; i <= combi_for_arr.length; i++) {
    combi.push(getCombinations(combi_for_arr, i));
  }
  // console.log(combi);

  for (let i = 0; i < combi.length; i++) {
    for (let j = 0; j < combi[i].length; j++) {
      Sibal(combi[i][j], relation, candidate_key);
    }
  }
  // console.log(candidate_key);
  return candidate_key.length;
}

function Sibal(combi, relation, candidate_key) {
  //최소성
  let isMinimalism = true;
  for (let i = 0; i < candidate_key.length; i++) {
    let prevKey = candidate_key[i];
    for (let j = 0; j < combi.length; j++) {
      prevKey = prevKey.filter((i) => i !== combi[j]);
    }
    if (prevKey.length === 0) {
      isMinimalism = false;
    }
  }
  if (!isMinimalism) {
    return;
  }

  // 유일성
  let isUnique = true;
  let arr = [];
  loop: for (let i = 0; i < relation.length; i++) {
    let temp = [];
    for (let j = 0; j < combi.length; j++) {
      temp.push(relation[i][combi[j]]);
    }
    for (let k = 0; k < arr.length; k++) {
      let isOverlap = true;
      for (let t = 0; t < temp.length; t++) {
        if (temp[t] !== arr[k][t]) {
          isOverlap = false;
          break;
        }
      }
      if (isOverlap) {
        isUnique = false;
        break loop;
      }
    }
    arr.push(temp);
  }
  if (isUnique) {
    candidate_key.push(combi);
  }
}

풀다 죽을뻔했다... 나중에 다른 사람 코드보거나 혼자서 수정...

programmers.co.kr/learn/courses/30/lessons/42890

 

 

방금그곡 -- 2018 KAKAO BLIND RECRUITMENT 

function solution(m, musicinfos) {
  let arr = [];
  musicinfos.forEach((val, idx) => {
    const spl = val.split(",");
    const start_time = spl[0].split(":");
    const end_time = spl[1].split(":");
    start_time[0] *= 1;
    start_time[1] *= 1;
    end_time[0] *= 1;
    end_time[1] *= 1;
    let time;
    if (end_time[0] < start_time[0]) {
      time =
        (end_time[0] - start_time[0] + 24) * 60 + end_time[1] - start_time[1];
    } else {
      time = (end_time[0] - start_time[0]) * 60 + end_time[1] - start_time[1];
    }
    // console.log(time);

    let sound = spl[3].split("");
    let sharp_idx = sound.indexOf("#");
    while (sharp_idx !== -1) {
      sound[sharp_idx - 1] = sound[sharp_idx - 1] + sound[sharp_idx];
      sound.splice(sharp_idx, 1);
      sharp_idx = sound.indexOf("#");
    }

    let really_sound = [];
    for (let i = 0; i < time; i++) {
      really_sound.push(sound[i % sound.length]);
    }
    // console.log(really_sound);

    let m_arr = m.split("");
    let m_idx = m_arr.indexOf("#");
    while (m_idx !== -1) {
      m_arr[m_idx - 1] = m_arr[m_idx - 1] + m_arr[m_idx];
      m_arr.splice(m_idx, 1);
      m_idx = m_arr.indexOf("#");
    }
    // console.log(m_arr);

    for (let i = 0; i <= really_sound.length - m_arr.length; i++) {
      if (m_arr.join("") === really_sound.slice(i, i + m_arr.length).join("")) {
        arr.push({ idx, name: spl[2], time });
        break;
      }
    }
  });

  arr.sort((a, b) => {
    if (a.time === b.time) return a.idx - b.idx;
    else return b.time - a.time;
  });

  // console.log(arr);
  return arr.length === 0 ? "(None)" : arr[0].name;
}

어렵지 않은데 짜증나게 뭔가 계속 테스트케이스 통과를 못했다... 개짜증.. 결국 그냥 하나하나 배열로 만들면서 고쳤음

programmers.co.kr/learn/courses/30/lessons/17683

 

3차 압축 -- 2018 KAKAO BLIND RECRUITMENT 

function solution(msg) {
  let answer = [];
  let arr = [0];
  for (let i = 1; i <= 26; i++) {
    arr.push(String.fromCharCode(64 + i));
  }
  for (let i = 0; i <= msg.length; i++) {
    if (!arr.includes(msg.slice(0, i + 1))) {
      answer.push(arr.indexOf(msg.slice(0, i)));
      arr.push(msg.slice(0, i + 1));
      msg = msg.substr(i);
      i = -1;
    }
  }
  msg && answer.push(arr.indexOf(msg));
  return answer;
}

 

그다지 어렵지 않은 문제였다. msg가 남아있을 때 예외처리

programmers.co.kr/learn/courses/30/lessons/17684

 

파일명 정렬 -- 2018 KAKAO BLIND RECRUITMENT 

function solution(files) {
  let arr = [];
  files.forEach((file, idx) => {
    const number_start = file.search(/[0-9]/);
    const number_end = number_start + file.slice(number_start).search(/[^0-9]/);
    // console.log(number_start,number_end)
    let head = file.slice(0, number_start);
    let number;
    number_end <= number_start
      ? (number = file.slice(number_start))
      : (number = file.slice(number_start, number_end));
    head = head.toUpperCase();
    while (number[0] == 0) {
      number = number.slice(1);
    }
    // console.log("head",head,"number",number);
    arr.push([head, number, idx, file]);
  });
  arr.sort((a, b) => {
    if (a[0] === b[0]) {
      if (a[1] === b[1]) {
        return a[2] - b[2];
      }
      return a[1] - b[1];
    } else {
      return a[0].localeCompare(b[0]);
    }
  });
  // console.log(arr);
  return arr.map((i) => i[3]);
}

 

이것도 문제는 쉬운데 tail이 빈 문자열인 경우 예외 처리를 안해서 고생했다..

programmers.co.kr/learn/courses/30/lessons/17686

 

n진수 게임  -- 2018 KAKAO BLIND RECRUITMENT 

function solution(n, t, m, p) {
    let arr=[];
    let i=0;
    loop:while(true){
        let num=i.toString(n);
        for(let j=0;j<num.length;j++){
            arr.push(num[j]);
            if(arr.length==t*m) break loop;
        }
        i++;
    }
    return arr.map((val,idx)=>{
        if(idx%m===p-1) return val;
    }).join('').toUpperCase();
}

 

이것도 그닥 어렵지 않은 문제다. 

programmers.co.kr/learn/courses/30/lessons/17687