[Algorithm] 프로그래머스 코딩테스트 Level1 풀이 모음 - JavaScript

프로그래머스 코딩테스트 Level1 풀이 모음입니다.

Ctrl + F 를 이용해 문제 풀이를 찾아주세요.

 

🔽 알고리즘 문제 (프로그래머스 사이트)

코딩테스트 연습

---

💡 행렬의 덧셈

function solution(arr1, arr2) {
    return arr1.map((arr, index) => arr.map((x, y) => x + arr2[index][y]));
}

 

 

💡 두 개 뽑아서 더하기

function solution(numbers) {
    var answer = [];
    for(let a = 0; a < numbers.length-1; a++) {
        for(let b = a+1; b < numbers.length; b++) {
            const sum = numbers[a] + numbers[b];
            if(answer.indexOf(sum) < 0) {
                answer.push(sum);
            }
        }
    }
    answer.sort((a, b) => a - b);
    return answer;
}

 

 

💡 제일 작은 수 제거하기

function solution(arr) {
    arr.splice(arr.findIndex((a) => a == Math.min(...arr)), 1);
    return arr.length < 0 ? arr = [-1] : arr;
}

 

 

💡 핸드폰 번호 가리기

function solution(phone_number){
  return "*".repeat(phone_number.length - 4) + phone_number.slice(-4);
}

// 정규식 표현
function solution(phone_number) {
    return phone_number.replace(/\d(?=\d{4})/g, "*");
}

 

 

💡 평균 구하기

function solution(arr) {
    return arr.reduce((acc, cur) => acc + cur) / arr.length;
}

 

 

💡 자연수 뒤집어 배열로 만들기

function solution(n) {
    return String(n).split('').map((x) => Number(x)).reverse();
}

 

 

💡 이상한 문자 만들기

function solution(s) {
    let arr = s.split(' ');
    let result = [];for(let i = 0; i < arr.length; i++) {
        let words = arr[i].split('').map((word, idx) => {
            return (idx % 2) ? word : word.toUpperCase();
        }).join('');
        result.push(words);
    }
    return result.join(' ');
}

 

 

💡 짝수와 홀수

function solution(num) {
    return (num % 2) ? "Odd" : "Even";
}

 

 

💡 자릿수 더하기

function solution(n) {
    return (n+'').split('').reduce((acc, cur) => acc + Number(cur), 0);
}

 

 

💡 x만큼 간격이 있는 n개의 숫자

function solution(x, n) {
    let arr = [];
    for(let i = 1; i <= n; i++) {
        arr.push(x*i);
    }
    return arr;
}

// Array Function으로 !
function solution(x, n) {
    return Array(n).fill(x).map((v, i) => (i + 1) * v)
}

 

 

💡 정수 내림차순으로 배치하기

function solution(n) {
    return Number(String(n).split('').sort((x, y) => y - x).join(''));
}

 

 

💡 문자열을 정수로 바꾸기

function solution(s) {
    return +s;
}

 

 

💡 정수 제곱근 판별

function solution(n) {
    let num = Math.sqrt(n);
    return Number.isInteger(num) ? (num+1) ** 2 : -1;
}

 

 

💡 직사각형 별찍기

process.stdin.setEncoding('utf8');
process.stdin.on('data', data => {
    const n = data.split(" ");
    const a = Number(n[0]), b = Number(n[1]);
    const row = '*'.repeat(a);
    for(let i = 0; i < b; i++) {
        console.log(row);
    }
});

 

 

💡 완주하지 못한 선수

function solution(participant, completion) {
    participant.sort();
    completion.sort();
    for(let i = 0; i < participant.length; i++) {
        if(participant[i] !== completion[i]) return participant[i];
    }
}

 

 

💡 없는 숫자 더하기

function solution(numbers) {
    let answer = 0;
    for(let i = 0; i < 10; i++) {
        if(!numbers.includes(i)) answer+=i;
    }
    return answer;
}

 

 

💡 문자열 내림차순으로 배치하기

function solution(s) {
    return s.split('').sort().reverse().join('');
}

 

 

💡 K번째수

function solution(array, commands) {
    let answer = [];
        for(let i = 0; i < commands.length; i++) {
            let list = array.slice(commands[i][0]-1, commands[i][1]).sort((a, b) => a - b);
            answer.push(list[commands[i][2]-1]);
        }
    return answer;
}

 

 

💡 수박수박수박수박수박수?

function solution(n) {
    return "수박".repeat(n).substring(0, n);
}

 

 

💡 내적

function solution(a, b) {
    return a.reduce((acc, _, i) => acc += a[i] * b[i], 0);
}

 

 

💡 가운데 글자 가져오기

function solution(s) {
    let strleng = Math.floor(s.length / 2);
    return s.length % 2 ? s.substr(strleng, 1) : s.substr(strleng-1, 2);
}

 

 

💡 나머지가 1이 되는 수 찾기

function solution(n) {
    for(let i = 2; i < n; i++) {
        if(n % i === 1) return i;
    }
}

/*
function solution(n, x = 2) {
    return n % x === 1 ? x : solution(n, x + 1);
}
*/

 

 

💡 부족한 금액 계산하기

function solution(price, money, count) {
    let answer = 0;
    for(let i = 1; i <= count; i++) {
        answer += price * i;
    }
    return money > answer ? 0 : answer-money;
}

// 가우스 공식 (등차수열의 합)
/*
function solution(price, money, count) {
    const tmp = price * count * (count + 1) / 2 - money;
    return tmp > 0 ? tmp : 0;
}
*/

 

 

💡 두 정수 사이의 합

function solution(a, b) {
    let answer = 0;
    if(a === b) {
        return a;
    } else {
        if(a > b) {
            let temp = a;
            a = b;
            b = temp;
        }
        for(let i = a; i <= b; i++) {
            answer += i;
        }
        return answer;
    }
}

/*
function solution(a, b) {
    let result = 0;
    return (a + b) * (Math.abs(b - a) + 1) / 2;
}
*/

 

 

💡 나누어 떨어지는 숫자 배열

function solution(arr, divisor) {
    let answer = arr.filter(a => a % divisor === 0).sort((a, b) => a - b);
    return answer.length === 0 ? [-1] : answer;
}

 

 

💡 2016년

function solution(a, b) {
    let dayOfTheWeek = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
    let days = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    b += 4;
    for(let i = 0; i < a-1; i++) {
        b += days[i];
   }
    return dayOfTheWeek[b % 7];
}

 

 

💡 문자열 내 p와 y의 개수

function solution(s){
  let count = 0;
  s = s.toLowerCase();
  for(let i = 0; i < s.length; i++) {
    if(s[i] === 'p') count++;
    else if(s[i] === 'y') count --;
}
  return count === 0 ? true : false;
}

/*
function solution(s) {
  return s.toLowerCase().split('p').length === s.toLowerCase().split('y').length;
}
*/

 

 

💡 콜라츠 추측

function solution(num) {
  let count = 0;
  while(num !== 1 && count !== 500) {
    num % 2 === 0 ? num /= 2 : num = num * 3 + 1;
    count++;
  }
  return num === 1 ? count : -1;
}

 

 

💡 서울에서 김서방 찾기

function solution(seoul) {
  return `김서방은 ${seoul.indexOf("Kim")}에 있다`;
}

 

 

💡 문자열 다루기 기본

function solution(s) {
  return (s.length === 4 || s.length === 6) && /^-?\d+$/.test(s);
}

 

 

💡 시저 암호

function solution(s, n) {
  return s.split('').map(val => {
      if(val === ' ') return val;
      const numCode = val.charCodeAt();
      return val.toUpperCase().charCodeAt() + n > 90 
          ? String.fromCharCode(numCode - 26 + n)
          : String.fromCharCode(numCode + n)
  }).join('')
}

 

 

💡 같은 숫자는 싫어

function solution(arr) {
    let answer = [];
    for(let i = 0; i < arr.length; i++) {
      if(arr[i] !== arr[i+1]) answer.push(arr[i]);
    }
    return answer;
}

/*
function solution(arr) {
    return arr.filter((val,index) => val != arr[index+1]);
}
*/

 

 

💡 음양 더하기

function solution(absolutes, signs) {
  let result = 0;
  absolutes.map((val, idx) => signs[idx] ? result += val : result += (-val));
  return result;
}

/*
function solution(absolutes, signs) {
  return absolutes.reduce((acc, val, i) => acc + (val * (signs[i] ? 1 : -1)), 0);
}
*/

 

 

💡 숫자 문자열과 영단어

function solution(s) {
  let answer = s;
  const numbers = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"];
  for(let i = 0; i < numbers.length; i++) {
    let arr = answer.split(numbers[i]);
    answer = arr.join(i);
  }
  return Number(answer);
}

 

 

💡 하샤드 수

function solution(x) {
  let num = String(x).split('').map(a => Number(a)).reduce((acc, cur) => acc + cur);
  return x % num === 0 ? true : false;
}

/*
function solution(x) {
  return x % (String(x).split('').reduce((acc, cur) => +cur + +acc)) === 0 ? true : false;
}
*/

 

 

💡 3진법 뒤집기

function solution(n) {
  let answer = 0;
  let stringNum = '';
  while(n !== 0) {
    stringNum += String(n % 3);
    n = Math.floor(n / 3);
  }
  stringNum.split('').reverse().map((val, idx) => {
    if(idx === 0) answer = Number(val) * 1;
    else answer += Number(val) * Math.pow(3, idx);
  })
  return answer;
}

/*
const solution = (n) => {
    return parseInt([...n.toString(3)].reverse().join(""), 3);
}
*/

- 숫자.toString(num) : 10진법인 숫자를 num진수로 변환하고 문자열로 변환함

- parseInt("문자열인 숫자", num) : 문자열인 숫자를 num진수로 변환하고 int형으로 변환함

 

 

💡 약수의 합

function solution(n) {
  let answer = 0;
  for(let i = 1; i <= n; i++) {
    if(n % i === 0) answer += i;   
  }
  return answer;
}

 

 

💡 약수의 개수와 덧셈

function solution(left, right) {
  let answer = 0;
  for(let i = left; i <= right; i++) {
    let count = 0;
    for(let y = 1; y <= i; y++) {
        if(i % y === 0) count++;
        if(i === y) {
            if(count % 2 === 0) answer += i;
            else answer -= i;
        }
    }
}
  return answer;
}

/*
function solution(left, right) {
    var answer = 0;
    for (let i = left; i <= right; i++) {
        if (Number.isInteger(Math.sqrt(i))) {
            answer -= i;
        } else {
            answer += i;
        }
    }
    return answer;
}
*/

 

 

💡 소수 찾기

function solution(n) {
  const s = new Set();
  for(let i = 2; i <= n; i++) s.add(i);
  for(let j = 2; j < Math.sqrt(n); j++) {
    if(s.has(j)) {
        for(let z = j*2; z <= n; z += j) s.delete(z);
    }
  }
  return s.size;
}

 

 

💡 문자열 내 마음대로 정렬하기

function solution(strings, n) {
  strings.sort((a, b) => {
    let first = a[n];
    let second = b[n];
    if(first === second) return (a > b) - (a < b);
    else return (first > second) - (first < second);
  });
  return strings;
}

/*
function solution(strings, n) {
  return strings.sort((s1, s2) => s1[n] === s2[n] ? s1.localeCompare(s2) : s1[n].localeCompare(s2[n]));
}
*/

- "문자1".localeCompare("문자2") : 영어 정렬 상 문자1이 문자2보다 먼저이면 1, 문자2가 먼저이면 -1, 같으면 0을 반환

 💡 "JavaScript".localeCompare("Database") => 1

     "JavaScript".localeCompare("zira") => -1

     "JavaScript".localeCompare("JavaScript") => 0

 

 

💡 예산

function solution(d, budget) {
  d.sort((a, b) => a - b);
  while(d.reduce((acc, cur) => (acc + cur), 0) > budget) {
    d.pop();
  }
  return d.length;
}

 

 

💡 비밀지도

function solution(n, arr1, arr2) {
  return arr1.map((v, i) => (v | arr2[i]).toString(2).padStart(n, "0").replace(/0/g," ").replace(/1/g,"#"));
}

/*
function solution(n, arr1, arr2) {
  return arr1.map((v, i) => (v | arr2[i]).toString(2).padStart(n, "0").replace(/1|0/g, a => +a ? "#" : " "));
}
*/

- 내 풀이는 0과 1에 대한 정규식 처리를 각자 해줬는데 다른 사람의 풀이(주석)에서는 삼항연산자로 깔끔하게 처리했다.. 기가 막힌 코드..

 

 

💡 다트 게임

function solution(dartResult) {
  let score = '';
  const scoreArr = [];
  const bonusArr = ["S", "D", "T"];

  for(let i = 0; i < dartResult.length; i++) {
    const current = dartResult[i];
    if(bonusArr.includes(current)) {
      scoreArr.push(parseInt(score) ** (bonusArr.indexOf(current)+1));
      score = '';
    } else if(current === "#") {
        scoreArr[scoreArr.length - 1] *= -1;
    } else if(current === "*") {
        const scoareArrLength = scoreArr.length;
        if(scoareArrLength === 1) {
            scoreArr[0] *= 2;
        }
        else if(scoareArrLength > 1) {
            scoreArr[scoareArrLength - 1] *= 2;
            scoreArr[scoareArrLength - 2] *= 2;
        }
    } else {
        score += current;
    }
  }

  return scoreArr.reduce((acc, cur) => acc + cur);
}

 

 

💡 최대공약수와 최소공배수

function solution(n, m) {
  const minNum = Math.min(n, m);
  const maxNum = Math.max(n, m);

  const gcd = (a, b) => a % b === 0 ? b : gcd(b, a % b);
  const lcm = (a, b) => a * b / gcd(a, b);

  return [gcd(maxNum, minNum), lcm(maxNum, minNum)];
}

 

 

💡 폰켓몬

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

 

 

💡 실패율

function solution(N, stages) {
  let answer = [];
  let clearPlayer = stages.length;
  for(let i = 1; i <= N; i++) {
    const notClearPlayer = stages.filter(x => x === i).length;
    answer.push([i, notClearPlayer / clearPlayer]);
    clearPlayer = clearPlayer - notClearPlayer;
  }
  return answer.sort((a, b) => b[1] - a[1]).map(v => v[0]);
}

 

 

💡 최소직사각형

function solution(sizes) {
  const rotate = sizes.map(([v, h]) => v > h ? [v, h] : [h, v]);
  let maxSize = [0, 0];
  rotate.forEach(([v, h]) => {
    if(v > maxSize[0]) maxSize[0] = v;
    if(h > maxSize[1]) maxSize[1] = h;
  });
  return maxSize[0] * maxSize[1];
}

 

 

💡 모의고사

function solution(answers) {
  let answer = [];
  let correctArr = [0, 0, 0];
  const one = [1, 2, 3, 4, 5];
  const two = [2, 1, 2, 3, 2, 4, 2, 5];
  const three = [3, 3, 1, 1, 2, 2, 4, 4, 5, 5];
  answers.map((v, i) => {
    if(one[i % 5] === v) correctArr[0]++;
    if(two[i % 8] === v) correctArr[1]++;
    if(three[i % 10] === v) correctArr[2]++;
  });
  const highScore = Math.max(...correctArr);
  correctArr.map((v, i) => { if(v === highScore) answer.push(i+1) });
  return answer;
}

 

 

💡 체육복

function solution(n, lost, reserve) {
  reserve.sort();
  lost.sort();
  const res = reserve.filter(x => !lost.includes(x));
  const los = lost.filter(y => !reserve.includes(y));
  for(let i in res) {
    for(let j in los) {
        if(los[j] === res[i]-1 || los[j] === res[i]+1) {
            los[j] = -1;
            break;
        }
    }
  }
  return n - los.filter(x => x !== -1).length;
}

 

 

💡 신고 결과 받기

function solution(id_list, report, k) {
  const set = [...new Set(report)];
  let answer = new Array(id_list.length);
  answer.fill(0);
  let reportList = [];
  let toBeReportCount = [];

  id_list.map(v => toBeReportCount.push([v, 0]));

  set.map(v => {
    const [reportId, toBeReportedId] = v.split(' ');
    reportList.push([reportId, toBeReportedId]);
    toBeReportCount.find(x => {
        if(x[0] === toBeReportedId) x[1]++;
    });
  });

  id_list.map((v, i) => {
    reportList.filter(x => x[0] === v).map((a, b) => {
        toBeReportCount.filter(y => y[0] === a[1]).map(z => {
            if(z[1] >= k) answer[i]++;
        });
    });
  });
  return answer;
}

 

 

💡 소수 만들기

const isPrime = (n) => {
  for(let i = 2; i <= Math.ceil(Math.sqrt(n)); i++) {
    if(n % i === 0) return false;
  }
  return true;
};

function solution(nums) {
  let answer = 0;
  nums.map((v, i) => {
    for(let a = i + 1; a < nums.length; a++) {
      for(let b = a + 1; b < nums.length; b++) {
        const num = v + nums[a] + nums[b];
        if(isPrime(num)) answer++;
      }
    }
  });
  return answer;
}

 

 

💡 크레인 인형뽑기 게임

function solution(board, moves) {
  let box = [];
  let answer = 0;
  moves.map(v => {
    const doll = pickup(board, v-1);
    if(doll) {
      if(box[box.length-1] === doll) {
        box.pop();
        answer += 2;
      } else {
        box.push(doll);
      }
    }
  });
  return answer;
}

function pickup(board, order) {
  for(let i = 0; i < board.length; i++) {
    if(board[i][order] !== 0) {
      const temp = board[i][order];
      board[i][order] = 0;
      return temp;
    }
  }
}

 

 

💡 로또의 최고 순위와 최저 순위

function solution(lottos, win_nums) {
  const rank = [6, 6, 5, 4, 3, 2, 1];

  const minCount = lottos.filter(v => win_nums.includes(v)).length;
  const zeroCount = lottos.filter(v => !v).length;

  const maxCount = minCount + zeroCount;

  return [rank[maxCount], rank[minCount]];
}

 

 

💡 신규 아이디 추천

function solution(new_id) {
  const answer = new_id
    .toLowerCase()
    .replace(/[^\w-_.]/g, '')
    .replace(/\.{2,}/g, '.')
    .replace(/^\.|\.$/g, '')
    .replace(/^$/, 'a')
    .slice(0, 15).replace(/\.$/, '');
  const len = answer.length;
  return len > 2 ? answer : answer + answer.charAt(len - 1).repeat(3 - len);
}

 

 

💡 키패드 누르기

function solution(numbers, hand) {
  let answer = '';
  const keys = {
    1: [0, 0], 2: [0, 1], 3: [0, 2],
    4: [1, 0], 5: [1, 1], 6: [1, 2],
    7: [2, 0], 8: [2, 1], 9: [2, 2],
    '*': [3, 0], 0: [3, 1], '#': [3, 2]
  };

  let leftHand = keys['*'];
  let rightHand = keys['#'];

  numbers.map(v => {
    let isLeft = false;
    if(v === 1 || v === 4 || v === 7) {
      isLeft = true;
    } else if(v === 3 || v === 6 || v === 9) {

    } else {
      const leftDistance = getDistance(leftHand, keys[v]);
      const rightDistance = getDistance(rightHand, keys[v]);

      if(leftDistance === rightDistance) {
        if(hand === 'left') isLeft = true;
      } else if(leftDistance < rightDistance) {
        isLeft = true;
      }
    }

    if(isLeft) {
      leftHand = keys[v];
      answer += 'L';
    } else {
      rightHand = keys[v];
      answer += 'R';
    }
  });

  return answer;
}

const getDistance = (start, target) => {
  let sum = 0;
  sum += Math.max(start[0], target[0]) - Math.min(start[0], target[0]);
  sum += Math.max(start[1], target[1]) - Math.min(start[1], target[1]);
  return sum;
};