[JavaScript/프로그래머스] 코딩 기초 트레이닝 - Day 1 ~ Day 25 까지

캘린더를 완성한 이후 풀었던 모든 문제들을 이 글에 담아 올립니다.

가장 최적화된 코드로 푼 것은 아니기에 코드를 본 후 본인만의 방법으로 코드를 재구성해보는 건 어떨까요?

문제를 풀어보고 싶다면?

코딩 기초 트레이닝 | 프로그래머스 스쿨

---

 

Day 1 - 출력

 

문자열 출력하기

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

let input = [];

rl.on("line", function (line) {
  input = [line];
}).on("close", function () {
  str = input[0];
  console.log(str);
});

 

a와 b 출력하기

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

let input = [];

rl.on("line", function (line) {
  input = line.split(" ");
}).on("close", function () {
  console.log(`a = ${Number(input[0])}`);
  console.log(`b = ${Number(input[1])}`);
});

 

문자열 반복해서 출력하기

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

let input = [];

rl.on("line", function (line) {
  input = line.split(" ");
}).on("close", function () {
  str = input[0];
  n = Number(input[1]);
  console.log(str.repeat(n));
});

 

대소문자 바꿔서 출력하기

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

let input = "";

rl.on("line", function (line) {
  input = line;
}).on("close", function () {
  let result = "";
  for (let i = 0; i < input.length; i++) {
    let char = input[i];
    if (char >= "a" && char <= "z") {
      result += char.toUpperCase(); // 소문자를 대문자로 변경
    } else {
      result += char.toLowerCase(); // 대문자를 소문자로 변경
    }
  }
  console.log(result);
});

 

특수문자 출력하기

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

rl.on("close", function () {
  console.log(`!@#$%^&*(\\'"<>?:;`);
});

 

Day 2 - 출력, 연산

 

덧셈식 출력하기

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

let input = [];

rl.on("line", function (line) {
  input = line.split(" ");
}).on("close", function () {
  console.log(
    `${Number(input[0])} + ${Number(input[1])} = ${
      Number(input[0]) + Number(input[1])
    }`
  );
});

 

문자열 붙여서 출력하기

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

let input = [];

rl.on("line", function (line) {
  input = line.split(" ");
}).on("close", function () {
  str1 = input[0];
  str2 = input[1];
  console.log(`${str1 + str2}`);
});

 

문자열 돌리기

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

let input = [];

rl.on("line", function (line) {
  input = [line];
}).on("close", function () {
  str = input[0];
  str.split("").forEach((s) => console.log(s));
});

 

홀짝 구분하기

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

let input = [];

rl.on("line", function (line) {
  input = line.split(" ");
}).on("close", function () {
  n = Number(input[0]);
  eo = n % 2 === 0 ? "even" : "odd";
  console.log(`${n} is ${eo}`);
});

 

문자열 겹쳐쓰기

function solution(my_string, overwrite_string, s) {
  let answer = ``;
  my_string = my_string.split("");
  for (let i = 0; i < s; i++) {
    answer += my_string[i];
  }
  answer += overwrite_string;
  for (let i = s + overwrite_string.length; i < my_string.length; i++) {
    answer += my_string[i];
  }
  return answer;
}

 

 

Day 3 - 연산

 

문자열 섞기

function solution(str1, str2) {
  let answer = "";
  for (let i = 0; i < str1.length; i++) {
    answer += `${str1[i] + str2[i]}`;
  }
  return answer;
}

 

문자 리스트를 문자열로 변환하기

const solution = (arr) => arr.join("");

 

문자열 곱하기

const solution = (my_string, k) => my_string.repeat(k);

 

더 크게 합치기

function solution(a, b) {
  return Math.max(parseInt(`${a}${b}`), parseInt(`${b}${a}`));
}

 

두 수의 연산값 비교하기

function solution(a, b) {
  return Math.max(`${a}${b}`, 2 * a * b);
}

 

Day 4 - 연산, 조건문

 

n의 배수

const solution = (num, n) => (num % n === 0 ? 1 : 0);

 

공배수

const solution = (number, n, m) =>
  number % n === 0 && number % m === 0 ? 1 : 0;

 

홀짝에 따라 다른 값 반환하기

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

 

조건 문자열

function solution(ineq, eq, n, m) {
  let answer = 0;
  // ineq 조건
  if (ineq === "<") {
    answer = n < m ? 1 : 0;
    if (eq === "=" && n === m) {
      answer = 1;
    }
  } else if (ineq === ">") {
    answer = n > m ? 1 : 0;
    if (eq === "=" && n === m) {
      answer = 1;
    }
  }
  return answer;
}

 

flag에 따라 다른 값 반환하기

const solution = (a, b, flag) => (flag ? a + b : a - b);

 

Day 5 - 조건문

 

코드 처리하기

function solution(code) {
  let answer = "";
  let mode = 0;
  for (let i = 0; i < code.length; i++) {
    if (code[i] === "1") {
      if (mode) {
        mode = 0;
      } else {
        mode = 1;
      }
      continue;
    }
    if (mode === 0 && i % 2 === 0) {
      answer += code[i];
    } else if (mode === 1 && i % 2 === 1) {
      answer += code[i];
    }
  }
  return answer ? answer : "EMPTY";
}

 

등차수열의 특정한 항만 더하기

function solution(a, d, included) {
  let answer = included[0] ? a : 0;
  let numArr = [a];
  for (let i = 1; i < included.length; i++) {
    numArr.push(numArr[i - 1] + d);
    if (included[i]) {
      answer += numArr[i];
    }
  }
  return answer;
}

 

주사위 게임 2

function solution(a, b, c) {
  let answer = 0;
  const uniqueNumber = new Set([a, b, c]);
  if (uniqueNumber.size === 2) {
    answer = (a + b + c) * (a ** 2 + b ** 2 + c ** 2);
  } else if (uniqueNumber.size === 1) {
    answer =
      (a + b + c) * (a ** 2 + b ** 2 + c ** 2) * (a ** 3 + b ** 3 + c ** 3);
  } else {
    answer = a + b + c;
  }

  return answer;
}

 

원소들의 곱과 합

function solution(num_list) {
  let square = 0;
  let times = 1;
  for (n of num_list) {
    square += n;
    times *= n;
  }
  if (square ** 2 > times) return 1;
  else return 0;
}

 

이어 붙인 수

function solution(num_list) {
  let even = "";
  let odd = "";
  num_list.forEach((n) => {
    even += n % 2 === 0 ? `${n}` : ``;
    odd += n % 2 === 1 ? `${n}` : ``;
  });
  return parseInt(even) + parseInt(odd);
}

 

Day 6 - 조건문, 반복문

 

마지막 두 원소

function solution(num_list) {
  const lastEl = num_list[num_list.length - 1];
  const beforeLastEl = num_list[num_list.length - 2];
  if (lastEl - beforeLastEl > 0) {
    num_list.push(lastEl - beforeLastEl);
  } else {
    num_list.push(lastEl * 2);
  }

  return num_list;
}

 

수 조작하기 1

function solution(n, control) {
  let answer = n;
  const command = {
    w: 1,
    s: -1,
    d: 10,
    a: -10,
  };
  control.split("").forEach((c) => {
    answer += command[c];
  });
  return answer;
}

 

수 조작하기 2

function solution(numLog) {
  let answer = "";
  const logic = {
    1: "w",
    "-1": "s",
    10: "d",
    "-10": "a",
  };
  for (let i = 1; i < numLog.length; i++) {
    answer += logic[numLog[i] - numLog[i - 1]];
  }
  return answer;
}

 

수열과 구간 쿼리 3

function solution(arr, queries) {
  for (q of queries) {
    [arr[q[0]], arr[q[1]]] = [arr[q[1]], arr[q[0]]];
  }
  return arr;
}

 

수열과 구간 쿼리 2

function solution(arr, queries) {
  let answer = [];
  for (let q of queries) {
    let sArr = [];
    let num = 0;
    for (let j = q[0]; j <= q[1]; j++) {
      sArr = [...sArr, arr[j]];
    }
    sArr.sort((a, b) => a - b);
    for (let s of sArr) {
      if (s > q[2]) {
        answer.push(s);
        num = 1;
        break;
      }
    }
    if (!num) answer.push(-1);
  }
  return answer;
}

 

Day 7 - 반복문

 

수열과 구간 쿼리 4

function solution(arr, queries) {
  let answer = [];
  for (q of queries) {
    for (let i = q[0]; i <= q[1]; i++) {
      if (i % q[2] === 0) {
        arr[i]++;
      }
    }
  }
  return arr;
}

 

배열 만들기 2

function solution(l, r) {
  function isOnlyZeroAndFive(num) {
    const numStr = String(num);
    for (let i = 0; i < numStr.length; i++) {
      if (numStr[i] !== "0" && numStr[i] !== "5") {
        return false;
      }
    }
    return true;
  }
  let answer = [];

  for (let num = l; num <= r; num++) {
    if (isOnlyZeroAndFive(num)) {
      answer.push(num);
    }
  }

  return answer.length > 0 ? answer : [-1];
}

 

카운트 업

function solution(start, end) {
  let answer = [];
  for (let i = start; i <= end; i++) {
    answer = [...answer, i];
  }
  return answer;
}

 

콜라츠 수열 만들기

function solution(n) {
  let answer = [n];
  while (n > 1) {
    if (n % 2 === 0) {
      n /= 2;
      answer.push(n);
    } else {
      n = n * 3 + 1;
      answer.push(n);
    }
  }
  return answer;
}

 

배열 만들기 4

function solution(arr) {
  let stk = [];
  let lastVal = 0;
  let i = 0;

  while (i < arr.length) {
    if (!stk.length) {
      stk.push(arr[i]);
      i++;
    } else if (stk[stk.length - 1] < arr[i]) {
      stk.push(arr[i]);
      i++;
    } else if (stk[stk.length - 1] >= arr[i]) {
      stk.pop();
    }
  }
  return stk;
}

 

Day 8 - 조건문, 문자열

 

간단한 논리 연산

function solution(x1, x2, x3, x4) {
  let answer = (x1 || x2) && (x3 || x4);
  return answer;
}

 

주사위 게임 3

function solution(a, b, c, d) {
  let numbers = [a, b, c, d];
  let counts = [0, 0, 0, 0, 0, 0, 0];
  for (let i = 0; i < numbers.length; i++) {
    counts[numbers[i]]++;
  }

  if (counts.includes(4)) {
    return 1111 * counts.indexOf(4);
  } else if (counts.includes(3)) {
    let p = counts.indexOf(3);
    let q = counts.lastIndexOf(1);
    return Math.pow(10 * p + q, 2);
  } else if (counts.includes(2)) {
    if (counts.lastIndexOf(2) !== counts.indexOf(2)) {
      let p = counts.indexOf(2);
      let q = counts.lastIndexOf(2);
      return (p + q) * Math.abs(p - q);
    } else {
      let p = counts.indexOf(2);
      let q = counts.indexOf(1);
      let r = counts.lastIndexOf(1);
      return q * r;
    }
  } else {
    return Math.min(...numbers);
  }
}

 

글자 이어 붙여 문자열 만들기

function solution(my_string, index_list) {
  let ans = "";
  index_list.forEach((i) => {
    ans += my_string[i];
  });
  return ans;
}

 

9로 나눈 나머지

function solution(number) {
  let answer = 0;
  for (let i = 0; i < number.length; i++) {
    answer += parseInt(number[i]);
  }
  return answer % 9;
}

 

문자열 여러 번 뒤집기

function solution(my_string, queries) {
  for (q of queries) {
    const startIndex = q[0];
    const endIndex = q[1];
    const substring = my_string.substring(startIndex, endIndex + 1);
    const reversedSubstring = substring.split("").reverse().join("");

    my_string =
      my_string.substring(0, startIndex) +
      reversedSubstring +
      my_string.substring(endIndex + 1);
  }

  return my_string;
}

 

Day 9 - 문자열

 

배열 만들기 5

function solution(intStrs, k, s, l) {
  let answer = [];
  for (i of intStrs) {
    let spl = i.split("").splice(s, l).join("");
    if (spl > k) answer.push(parseInt(spl));
  }
  return answer;
}

 

부분 문자열 이어 붙여 문자열 만들기

function solution(my_strings, parts) {
  let answer = "";
  for (let i = 0; i < my_strings.length; i++) {
    answer += my_strings[i].slice(parts[i][0], parts[i][1] + 1);
  }

  return answer;
}

 

문자열의 뒤의 n글자

const solution = (my_string, n) =>
  my_string
    .split("")
    .splice(my_string.length - n, my_string.length)
    .join("");

 

접미사 배열

function solution(my_string) {
  let answer = [];
  for (let i = 0; i < my_string.length; i++) {
    answer.push(my_string.slice(i, my_string.length));
  }

  return answer.sort();
}

 

접미사인지 확인하기

function solution(my_string, is_suffix) {
  let answer = 0;
  const checkLastAlphabet =
    my_string[my_string.length - 1] === is_suffix[is_suffix.length - 1];
  const includesSuffix = my_string.includes(is_suffix);
  return (answer = checkLastAlphabet && includesSuffix ? 1 : 0);
}

 

Day 10 - 문자열

 

문자열의 앞의 n글자

const solution = (my_string, n) => my_string.split("").splice(0, n).join("");

 

접두사인지 확인하기

function solution(my_string, is_prefix) {
  if (
    my_string.split("").splice(0, is_prefix.length).join("") === is_prefix &&
    my_string.includes(is_prefix)
  ) {
    return 1;
  }
  return 0;
}

 

문자열 뒤집기

function solution(my_string, s, e) {
  let answer = "";
  for (let i = 0; i < s; i++) {
    answer += my_string[i];
  }
  for (let i = e; i >= s; i--) {
    answer += my_string[i];
  }
  for (let i = e + 1; i < my_string.length; i++) {
    answer += my_string[i];
  }
  return answer;
}

 

세로 읽기

function solution(my_string, m, c) {
  let answer = "";
  for (let i = c - 1; i < my_string.length; i += m) {
    answer += my_string[i];
  }
  return answer;
}

 

qr code

function solution(q, r, code) {
  let answer = "";
  for (let i = 0; i < code.length; i++) {
    if (i % q === r) {
      answer += code[i];
    }
  }
  return answer;
}

 

Day 11 - 리스트(배열)

 

문자 개수 세기

function solution(my_string) {
  const alpha = [
    "A", "B", "C", "D", "E", "F", "G", "H", "I",
    "J", "K", "L", "M", "N", "O", "P", "Q", "R",
    "S", "T", "U", "V", "W", "X", "Y", "Z",
    "a", "b", "c", "d", "e", "f", "g", "h", "i",
    "j", "k", "l", "m", "n", "o", "p", "q", "r",
    "s", "t", "u", "v", "w", "x", "y", "z",
  ];
  let answer = new Array(alpha.length).fill(0);
  for (let i in my_string) {
    answer[alpha.indexOf(my_string[i])] += 1;
  }
  return answer;
}

 

배열 만들기 1

function solution(n, k) {
  let answer = [];
  for (let i = k; i <= n; i += k) {
    answer = [...answer, i];
  }
  return answer;
}

 

글자 지우기

function solution(my_string, indices) {
  let answer = "";
  for (let i = 0; i < my_string.length; i++) {
    if (indices.includes(i)) {
      continue;
    }
    answer += my_string[i];
  }
  return answer;
}

 

카운트 다운

function solution(start, end) {
  let answer = [];
  for (let i = start; i >= end; i--) {
    answer = [...answer, i];
  }
  return answer;
}

 

가까운 1 찾기

function solution(arr, idx) {
  let answer = -1;
  for (let i = idx; i < arr.length; i++) {
    if (arr[i] === 1) {
      return i;
    }
  }
  return answer;
}

 

Day 12 - 리스트(배열)

 

리스트 자르기

function solution(n, slicer, num_list) {
  const [a, b, c] = slicer;
  let answer = [];

  if (n === 1) {
    answer = num_list.slice(0, b + 1);
  } else if (n === 2) {
    answer = num_list.slice(a);
  } else if (n === 3) {
    answer = num_list.slice(a, b + 1);
  } else if (n === 4) {
    answer = num_list.slice(a, b + 1).filter((_, i) => i % c === 0);
  }

  return answer;
}

 

첫 번째로 나오는 음수

function solution(num_list) {
  let num = 0;
  for (let i = 0; i < num_list.length; i++) {
    if (num_list[i] < 0) return i;
  }
  return -1;
}

 

배열 만들기 3

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

 

2의 영역

function solution(arr) {
  let answer = [];
  let arrReverse = [...arr];
  arrReverse.reverse();
  let count = 0;
  // 정상 2 index, reverse 2 index 구하기
  answer = arr.slice(arr.indexOf(2), arr.length - arrReverse.indexOf(2));
  if (arr.indexOf(2) === -1) {
    answer = [-1];
  }
  return answer;
}

 

배열 조각하기

function solution(arr, query) {
  let answer = [...arr];
  for (let i = 0; i < query.length; i++) {
    if (i % 2 === 0) {
      answer = answer.slice(0, query[i] + 1);
    } else {
      answer = answer.slice(query[i], answer.length);
    }
  }
  return answer;
}

 

Day 13 - 리스트(배열)

 

n 번째 원소부터

const solution = (num_list, n) => num_list.splice(n - 1);

 

순서 바꾸기

function solution(num_list, n) {
  let answer = [];
  for (let i = n; i < num_list.length; i++) {
    answer.push(num_list[i]);
  }
  for (let i = 0; i < n; i++) {
    answer.push(num_list[i]);
  }
  return answer;
}

 

왼쪽 오른쪽

function solution(str_list) {
  let answer = [];
  const lIndex = str_list.indexOf("l");
  const rIndex = str_list.indexOf("r");

  if (lIndex === -1 && rIndex === -1) {
    answer = [];
  } else if (lIndex === -1) {
    answer = str_list.slice(rIndex + 1);
  } else if (rIndex === -1) {
    answer = str_list.slice(0, lIndex);
  } else if (lIndex < rIndex) {
    answer = str_list.slice(0, lIndex);
  } else {
    answer = str_list.slice(rIndex + 1);
  }

  return answer;
}

 

n 번째 원소까지

function solution(num_list, n) {
  return num_list.splice(0, n);
}

 

n개 간격의 원소들

function solution(num_list, n) {
  let answer = [];
  for (let i = 0; i < num_list.length; i += n) {
    answer = [...answer, num_list[i]];
  }
  return answer;
}

 

Day 14 - 리스트(배열)

 

홀수 vs 짝수

function solution(num_list) {
  let evenSum = (oddSum = 0);
  for (let i = 0; i < num_list.length; i++) {
    if (i % 2 === 0) {
      evenSum += num_list[i];
    } else {
      oddSum += num_list[i];
    }
  }
  return Math.max(evenSum, oddSum);
}

 

5명씩

function solution(names) {
  let answer = [];
  for (let i = 0; i < names.length; i += 5) {
    answer.push(names[i]);
  }
  return answer;
}

 

할 일 목록

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

 

n보다 커질 때까지 더하기

function solution(numbers, n) {
  let answer = 0;

  for (num of numbers) {
    answer += num;
    if (answer > n) break;
  }

  return answer;
}

 

수열과 구간 쿼리 1

function solution(arr, queries) {
  for (let q of queries) {
    for (let i = q[0]; i <= q[1]; i++) {
      arr[i] += 1;
    }
  }
  return arr;
}

 

Day 15 - 리스트(배열), 문자열

 

조건에 맞게 수열 변환하기 1

function solution(arr) {
  let ans = [];
  for (let a of arr) {
    if (a >= 50 && a % 2 === 0) {
      ans.push(a / 2);
    } else if (a < 50 && a % 2 === 1) {
      ans.push(a * 2);
    } else {
      ans.push(a);
    }
  }
  return ans;
}
// 스프레드 연산자와 forEach 사용 시 시간초과

 

조건에 맞게 수열 변환하기 2

function solution(arr) {
  let x = 0;

  while (true) {
    let newArr = arr.map((val) =>
      val >= 50 && val % 2 === 0
        ? val / 2
        : val < 50 && val % 2 !== 0
        ? val * 2 + 1
        : val
    );

    if (JSON.stringify(arr) === JSON.stringify(newArr)) {
      break;
    }

    arr = newArr;
    x++;
  }

  return x;
}

 

1로 만들기

function solution(num_list) {
  let answer = 0;
  for (n of num_list) {
    while (n > 1) {
      n = n % 2 === 0 ? n / 2 : (n - 1) / 2;
      answer += 1;
    }
  }
  return answer;
}

 

길이에 따른 연산

function solution(num_list) {
  let answer = 0;
  if (num_list.length >= 11) {
    num_list.forEach((n) => {
      answer += n;
    });
  } else {
    answer = 1;
    num_list.forEach((n) => {
      answer *= n;
    });
  }
  return answer;
}

 

원하는 문자열 찾기

function solution(myString, pat) {
  myString = myString.toLowerCase();
  pat = pat.toLowerCase();
  return myString.includes(pat) ? 1 : 0;
}

 

Day 16 - 문자열

 

대문자로 바꾸기

const solution = (myString) => myString.toUpperCase();

 

소문자로 바꾸기

const solution = (myString) => myString.toLowerCase();

 

배열에서 문자열 대소문자 변환하기

function solution(strArr) {
  let ans = [];
  for (let i = 0; i < strArr.length; i++) {
    ans = [
      ...ans,
      i % 2 === 0 ? strArr[i].toLowerCase() : strArr[i].toUpperCase(),
    ];
  }
  return ans;
}

 

A 강조하기

function solution(myString) {
  let ans = "";
  myString.split("").forEach((m) => {
    ans += m === "a" || m === "A" ? m.toUpperCase() : m.toLowerCase();
  });
  return ans;
}

 

특정한 문자를 대문자로 바꾸기

function solution(my_string, alp) {
  let answer = "";
  for (ms of my_string) {
    answer += ms === alp ? ms.toUpperCase() : ms;
  }
  return answer;
}

 

Day 17 - 문자열

 

특정 문자열로 끝나는 가장 긴 부분 문자열 찾기

function solution(myString, pat) {
  let answer = "";
  let reversePat = pat.split("").reverse().join("");
  let reverseMyString = myString.split("").reverse().join("");

  return myString.slice(
    0,
    myString.length - reverseMyString.indexOf(reversePat)
  );
}

 

문자열이 몇 번 등장하는지 세기

function solution(myString, pat) {
  let answer = 0;
  for (let i = 0; i <= myString.length - pat.length; i++) {
    let isSame = "";
    for (let j = i; j < i + pat.length; j++) {
      isSame += myString[j];
    }
    if (isSame === pat) answer += 1;
  }
  return answer;
}

 

ad 제거하기

function solution(strArr) {
  let answer = [];
  for (str of strArr) {
    if (str.includes("ad")) {
      continue;
    }
    answer.push(str);
  }
  return answer;
}

 

공백으로 구분하기 1

function solution(my_string) {
  return my_string.split(" ");
}

 

공백으로 구분하기 2

function solution(my_string) {
  let ans = [];
  my_string.split(" ").forEach((m) => {
    if (m !== "") {
      ans.push(m);
    }
  });

  return ans;
}

 

Day 18 - 문자열

 

x 사이의 개수

function solution(myString) {
  let splitedString = [];
  myString = myString.split("x");
  console.log(myString);
  for (let i = 0; i < myString.length; i++) {
    splitedString.push(myString[i].length);
  }
  return splitedString;
}

 

문자열 잘라서 정렬하기

function solution(myString) {
  let answer = [];
  myString = myString.split("x");
  for (let i = 0; i < myString.length; i++) {
    if (myString[i] !== "") {
      answer.push(myString[i]);
    }
  }
  return answer.sort();
}

 

간단한 식 계산하기

function solution(binomial) {
  let answer = 0;
  binomial = binomial.split(" ");
  if (binomial.includes("+")) {
    answer = parseInt(binomial[0]) + parseInt(binomial[2]);
  } else if (binomial.includes("-")) {
    answer = parseInt(binomial[0]) - parseInt(binomial[2]);
  } else {
    answer = parseInt(binomial[0]) * parseInt(binomial[2]);
  }
  return answer;
}

 

문자열 바꿔서 찾기

function solution(myString, pat) {
  let answer = 0;
  let myStringAfter = "";
  myString.split("").forEach((m) => {
    myStringAfter += m === "A" ? "B" : "A";
  });
  return (answer = myStringAfter.includes(pat) ? 1 : 0);
}

 

rny_string

function solution(rny_string) {
  let answer = "";
  rny_string.split("").forEach((rn) => {
    answer += rn === "m" ? "rn" : rn;
  });
  return answer;
}

 

Day 19 - 문자열, 리스트(배열)

 

세 개의 구분자

function solution(myStr) {
  let splitArr = myStr.split(/[abc]+/); // "a", "b", "c"를 구분자로 사용하여 문자열을 분리합니다.
  let answer = splitArr.filter((item) => item !== ""); // 빈 문자열을 제거합니다.

  if (answer.length === 0) {
    answer.push("EMPTY");
  }

  return answer;
}

 

배열의 원소만큼 추가하기

function solution(arr) {
  let answer = [];
  arr.forEach((a) => {
    for (let i = 0; i < a; i++) {
      answer = [...answer, a];
    }
  });
  return answer;
}

 

빈 배열에 추가, 삭제하기

function solution(arr, flag) {
  let answer = [];
  for (let i = 0; i < arr.length; i++) {
    // flag의 true, false 확인
    if (flag[i]) {
      for (let j = 0; j < arr[i] * 2; j++) {
        answer.push(arr[i]);
      }
    } else if (!flag[i]) {
      for (let j = 0; j < arr[i]; j++) {
        answer.pop();
      }
    }
  }
  return answer;
}

 

배열 만들기 6

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

 

무작위로 K개의 수 뽑기

function solution(arr, k) {
  let answer = [...new Set(arr)];
  if (answer.length <= k) {
    answer.push(...Array(k - answer.length).fill(-1));
  } else if (answer.length > k) {
    while (answer.length !== k) {
      answer.pop();
    }
  }
  return answer;
}

 

Day 20 - 함수(메서드)

 

배열의 길이를 2의 거듭제곱으로 만들기

function solution(arr) {
  if (arr.length === 0) {
    return [];
  }

  let answer = [...arr];
  let num = 1;
  while (arr.length > num) {
    num *= 2;
  }

  if (num > arr.length) {
    for (let i = 0; i < num - arr.length; i++) {
      answer.push(0);
    }
  }

  return answer;
}

 

배열 비교하기

function solution(arr1, arr2) {
  let answer = 0;
  let arr1Sum = 0;
  let arr2Sum = 0;
  const same = arr1.length === arr2.length;
  if (same) {
    for (let i = 0; i < arr1.length; i++) {
      arr1Sum += arr1[i];
      arr2Sum += arr2[i];
    }
    if (arr1Sum > arr2Sum) {
      return 1;
    } else if (arr1Sum < arr2Sum) {
      return -1;
    } else {
      return 0;
    }
  } else {
    if (arr1.length > arr2.length) {
      return 1;
    } else {
      return -1;
    }
  }
  return answer;
}

 

문자열 묶기

function solution(strArr) {
  const count = (arr, val) => arr.filter((n) => n.length === val).length;
  let arr = [];
  let countArr = [];
  for (let i = 0; i < strArr.length; i++) {
    arr.push(strArr[i].length);
  }
  arr = [...new Set(arr)];
  for (let i = 0; i < arr.length; i++) {
    countArr.push(count(strArr, arr[i]));
  }

  return Math.max(...countArr);
}

 

배열의 길이에 따라 다른 연산하기

function solution(arr, n) {
  let ans = [];
  for (let i = 0; i < arr.length; i++) {
    if (arr.length % 2 === 0 && i % 2 === 1) {
      ans.push(arr[i] + n);
    } else if (arr.length % 2 === 1 && i % 2 === 0) {
      ans.push(arr[i] + n);
    } else {
      ans.push(arr[i]);
    }
  }

  return ans;
}

 

뒤에서 5등까지

function solution(num_list) {
  let answer = [];
  num_list.sort((a, b) => a - b);
  for (let i = 0; i < 5; i++) {
    answer.push(num_list[i]);
  }
  return answer;
}

 

Day 21 - 함수(메서드)

 

뒤에서 5등 위로

function solution(num_list) {
  num_list.sort((a, b) => a - b);
  for (let i = 0; i < 5; i++) {
    num_list.shift();
  }
  return num_list;
}

 

전국 대회 선발 고사

function solution(rank, attendance) {
  const students = rank.map((value, index) => ({
    rank: value,
    attendance: attendance[index],
    index,
  }));

  students.sort((a, b) => a.rank - b.rank);

  const selected = students
    .filter((student) => student.attendance)
    .slice(0, 3)
    .map((student) => student.index);

  return selected[0] * 10000 + selected[1] * 100 + selected[2];
}

 

정수 부분

const solution = (flo) => parseInt(flo);

 

문자열 정수의 합

function solution(num_str) {
  let answer = 0;
  num_str.split("").forEach((n) => (answer += parseInt(n)));
  return answer;
}

 

문자열을 정수로 변환하기

const solution = (n_str) => parseInt(n_str);

 

Day 22 - 함수(메서드), 조건문 활용

 

0 떼기

function solution(n_str) {
  return `${parseInt(n_str)}`;
}

 

두 수의 합

function solution(a, b) {
  a = BigInt(a);
  b = BigInt(b);
  return `${a + b}`;
}

 

문자열로 변환

const solution = (n) => `${n}`;

 

배열의 원소 삭제하기

function solution(arr, delete_list) {
  let answer = [];
  for (let i = 0; i < arr.length; i++) {
    if (delete_list.includes(arr[i])) {
      continue;
    }
    answer.push(arr[i]);
  }
  return answer;
}

 

부분 문자열인지 확인하기

function solution(my_string, target) {
  if (my_string.includes(target)) return 1;
  else return 0;
}

 

Day 23 - 조건문 활용

 

부분 문자열

function solution(str1, str2) {
  return str2.includes(str1) ? 1 : 0;
}

 

꼬리 문자열

function solution(str_list, ex) {
  let answer = "";
  for (str of str_list) {
    answer += !str.includes(ex) ? str : "";
  }
  return answer;
}

 

정수 찾기

function solution(num_list, n) {
  if (num_list.includes(n)) return 1;

  return 0;
}

// 왜 includes는 되고 n in num_list는 안될까?

 

주사위 게임 1

function solution(a, b) {
  let answer = 0;
  let eoA = a % 2;
  let eoB = b % 2;
  if (eoA && eoB) {
    answer = a ** 2 + b ** 2;
  } else if (eoA || eoB) {
    answer = 2 * (a + b);
  } else {
    answer = Math.abs(a - b);
  }
  return answer;
}

 

날짜 비교하기

function solution(date1, date2) {
  let answer = 0;
  date1 = new Date(`${date1[0]}-${date1[1]}-${date1[2]}`);
  date2 = new Date(`${date2[0]}-${date2[1]}-${date2[2]}`);
  answer = date1 - date2;
  return answer < 0 ? 1 : 0;
}

 

Day 24 - 조건문 활용, 반복문 활용, 이차원 리스트(배열)

 

커피 심부름

function solution(order) {
  let answer = 0;
  const menuName = ["americano", "cafelatte", "anything"];
  const menuCost = [4500, 5000, 4500];
  for (let i = 0; i < order.length; i++) {
    for (let j = 0; j < menuName.length; j++) {
      if (order[i].includes(menuName[j])) {
        answer += menuCost[j];
      }
    }
  }
  return answer;
}

 

그림 확대

function solution(picture, k) {
  const expandedPicture = [];

  // 주어진 picture 배열의 각 문자열을 k배로 늘립니다.
  for (let i = 0; i < picture.length; i++) {
    const originalRow = picture[i];
    let expandedRow = "";

    // 각 문자열의 모든 문자를 k번 반복하여 새로운 문자열을 생성합니다.
    for (let j = 0; j < originalRow.length; j++) {
      const originalPixel = originalRow[j];
      expandedRow += originalPixel.repeat(k);
    }

    // k배로 늘린 문자열을 배열에 추가합니다.
    for (let j = 0; j < k; j++) {
      expandedPicture.push(expandedRow);
    }
  }

  return expandedPicture;
}

 

조건에 맞게 수열 변환하기 3

function solution(arr, k) {
  if (k % 2 === 0) {
    arr = arr.map((a) => a + k);
  } else {
    arr = arr.map((a) => a * k);
  }
  return arr;
}

 

l로 만들기

function solution(myString) {
  let answer = "";
  const beforeI = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"];
  myString.split("").forEach((m) => {
    if (beforeI.includes(m)) {
      answer += "l";
    } else {
      answer += m;
    }
  });
  return answer;
}

 

특별한 이차원 배열 1

function solution(n) {
  let answer = Array(n)
    .fill(0)
    .map(() => Array(n).fill(0));
  for (let i = 0; i < answer.length; i++) {
    answer[i][i] = 1;
  }
  return answer;
}

 

Day 25 - 이차원 리스트(배열)

 

정수를 나선형으로 배치하기

function solution(n) {
  let squareArr = new Array(n).fill().map(() => new Array(n).fill(0));
  let counter = 1;
  let startRow = 0;
  let endRow = n - 1;
  let startCol = 0;
  let endCol = n - 1;

  while (startRow <= endRow && startCol <= endCol) {
    for (let i = startCol; i <= endCol; i++) {
      squareArr[startRow][i] = counter++;
    }
    startRow++;
    for (let i = startRow; i <= endRow; i++) {
      squareArr[i][endCol] = counter++;
    }
    endCol--;
    if (startRow <= endRow) {
      for (let i = endCol; i >= startCol; i--) {
        squareArr[endRow][i] = counter++;
      }
      endRow--;
    }
    if (startCol <= endCol) {
      for (let i = endRow; i >= startRow; i--) {
        squareArr[i][startCol] = counter++;
      }
      startCol++;
    }
  }
  return squareArr;
}

 

특별한 이차원 배열 2

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

 

정사각형으로 만들기

function solution(arr) {
  let answer = [[]];
  const maxSquare = Math.max(arr.length, arr[0].length);
  const squareArr = Array(maxSquare)
    .fill()
    .map(() => Array(maxSquare).fill(0));
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr[i].length; j++) {
      squareArr[i][j] = arr[i][j];
    }
  }
  return squareArr;
}

 

이차원 배열 대각선 순회하기

function solution(board, k) {
  let answer = 0;
  for (let i = 0; i < board.length && i <= k; i++) {
    for (let j = 0; j < board[i].length && j <= k - i; j++) {
      answer += board[i][j];
    }
  }
  return answer;
}

 

---

End