laetipark (박동훈)

구글 SEO(검색엔진 최적화) 개념 정리

Wed, 19 Feb 2025 13:39:03 +0900

SEO란?

SEO(Search Engine Optimization) : 웹사이트가 검색 결과에 더 잘 보이도록 최적화하는 과정
- 검색엔진 최적화 작업으로 검색로봇이 웹사이트를 방문했을 때, 검색 결과 상단에 노출될 수 있도록 해당 사이트의 구조, 본문 콘텐츠, 링크 등을 개선하는 작업
- 즉, 사이트를 검색 엔진이 선호하는 타입으로 최적화하는 작업
PPC(Pay per click) : 클릭 당 지불이라는 뜻으로 보통 검색 광고를 뜻함 CPC

SEO를 하는 이유

이미 관심이 가는 단어를 결정하고 검색창에 입력한 단어는 서비스 이용 또는 구매로 연결될 가능성이 높음
인터넷 잠재 고객들은 광고로 표시된 검색 결과보다 자연 검색 결과를 더 신뢰하기 때문에 브랜드 신뢰도를 올리고 정확한 마케팅을 할 수 있음

PPC는 한정된 클릭 수 당 고정 비용 계속 발생
SEO는 검색순위가 향상될수록 Organic Traffic(자연 발생 트래픽) 당 비용이 감소하여 기간이 지날 수록 ROI(Return on Investment)가 극대화

SEO 작업 3 요소

On-Server SEO(Technical SEO) : 서버 단위에서 검색 최적화
On-Page SEO(Body Optimization) : 웹페이지 HTML소스의 검색 최적화
Off-Page SEO(Link Building) : 웹사이트로의 링크의 다양화 및 고급화

On-Server(On-Page) SEO

웹사이트의 형식, 주소(URL) 체계, 폴더/파일 네이밍 체계, 사이트의 속도, 웹표준 규약, Javascript 등 프로그래밍 요소, XML 사이트맵의 존재 유무, Robot 태그 등 서버에서의 웹사이트 규칙, 규약, 형태 등을 최적화하는 작업

웹 사이트 형식, 주소 체계

URL 주소 길이 : 최대한 짧게하며, Depth(/)는 2~4 추천
URL에 특정 Parameter(!$#% 등 특수 기호) 사용 금지
페이지의 주제를 나타내는 키워드 포함하고 URL Rewriting 기법 활용
- URL Rewriting : URL 구조를 더 친화적이고 검색 엔진 친화적으로 수정하는 SEO 기법
  - example.com/page?id=123를 example.com/product/shoes처럼 변환하는 작업
  - 가독성이 향상되며, 사용자 링크 공유/북마크에 용이하며, 중복 콘텐츠 문제가 감소됨
단어의 구분은 언더바(_)가 아닌 대쉬(-)사용

모바일 호환 및 페이지 속도 측정 : PageSpeed Insights

웹페이지 URL 입력 후 모바일/데스크톱에서 호환성 및 페이지 속도 측정

웹표준 점검 : https://validator.w3.org

브라우저가 다르더라도 잘 호환되어 보이는 정도를 점검
- Address에 점검하고 싶은 주소 입력

깨진 링크 점검 : https://validator.w3.org/checklink

404 Not Found 같은 링크는 세부 페이지까지 방문하여, 색인 작업하는 검색 로봇의 검색 활동을 중단시키는 원인
Address에 점검하고 싶은 주소 입력

XML 사이트맵 제작

구글에 xml sitemap generator 입력 후 sitemap 생성

사이트 파악 및 오류 등 개선 : https://search.google.com/search-console/about

On-Page SEO

웹페이지의 HTML 소스를 최적화 하여, 검색 엔진이 해당 페이지를 더 잘 이해할 수 있도록 하는 작업 실제 검색 엔진이 읽는 내용은 페이지에서 보이는 내용과 다르기 때문에, 페이지를 잘 읽어오면서 타이틀과 메타 설명문구, 그리고 본문에 주요 키워드에 대한 내용을 적절하게 넣어주어야 함

제목(Title)과 메타 설명(Meta Description)

Title, Meta Tag : 검색 엔진이 사이트 방문 시 가장 인식하는 텍스트로 태그 내 문구를 통해 해당 페이지의 주제어 및 관련 키워드를 파악
- Title은 브라우저 상단에 제목으로 표시되고, Meta Description은 검색결과의 사이트 설명문구
```

<!DOCTYPE html>
<html lang="ko">
  <head>
    <title>제목</title>
    <meta name="description" content="설명" />
    <meta name="keywords" content="키워드" />
    <meta property="og:title" content="제목" />
    <meta property="og:description" content="설명" />
  </head>
</html>
```
- Title 1. 소비자가 매력을 느낄만한 제목으로 작성하는 것이 검색에 유리
  1. 대상 키워드를 반드시 1회 포함(긴 타이틀의 경우 2회까지 가능하나 유의) - 제목에 많은 내용이 들어있다면 유익한 정보가 없다고 인식할 수 있음 - 키워드가 앞으로 나올수록 검색에 유리 - 키워드가 전체 밀도에서 많이 차지 할수록 검색에 유리
  2. 최대 문자 사용 수는 60자, 가능한 55자 내외로 작성
  3. 페이지 별 각각 다른 Title을 작성
- Meta Description
  1. 클릭을 유도할 수 있는 매력적인 문구를 작성
  2. 문자 250자(약 2줄)를 넘지 않도록 작성
  3. 페이지 별로 각각 다른 Description을 작성
타이틀과 메타는 페이지마다 다르게 작성하고 주요 키워드를 포함시킨다.

본문 Text 최적화 작업

웹 페이지 구조를, 검색엔진이 인식 할 수 있는 텍스트 콘텐츠 위주로 구성
본문 내 적절한 키워드 밀도가 중요, 가능한 앞에 키워드를 작성하는 것을 추천
대상 키워드에 <H1> 또는 <H2> 태그 사용(<H1> 태그는 페이지 당 1회)
- h 태그를 단계적으로 순차적으로 사용하는 것이 색인하는 데 좋음
주요 키워드 강조 방식 활용
이미지 alt 속성
```
<img src="이미지 주소" alt="">
```
- 이미지에 Alt 태그 사용은 이미지 검색 지원에 도움을 줌

사이트 분석

Google Analytics: https://marketingplatform.google.com/about/analytics/

Off-Page SEO

웹 사이트 외부에서 수행하는 작업으로, 유명한 사이트에 자신의 사이트 링크를 많이 등록하는 작업을 주로 함

Domain Authority(DA) & Page Authority(PA)
- 사이트(도메인)와 페이지의 품질 지수
- 100점 만점에 가까울 수록 높은 품질
- 내 사이트보다 품질 지수가 높은 사이트에 링크를 거는 것은 긍정적 영향을 받을 수 있음
- DA/PA 점수의 중장기적인 모니터링을 통해 사이트의 인기도를 측정
- 구글 검색창에 “da pa checker” 입력 후 검색하여 품질 지수 확인 가능

참고

Javascript/Algorithm : 전위/중위/후위 표기법

Sat, 08 Jun 2024 01:17:32 +0900

개요

회사에서 간단한 실습 과제로 회사 솔루션의 에디터 내 계산기 기능을 구현하는 것이 주어졌다. 그래서 전위, 중위, 후위 표기법에 대해 다시 공부하면서, 후위 표기법을 통한 계산으로 구현한 Javascript 코드를 작성해보았다.

중위 표기법

중위 표기법(infix) : 피연산자 사이 연산자가 있는 형태로 일반적으로 사용하는 수식 표기법이다. 괄호와 연산자 우선순위를 고려한 다음 순서대로 연산이 이루어진다.
컴퓨터는 왼쪽부터 수식을 하나씩 읽어가기 때문에, 우선순위가 있는 중위 표기법으로 구현하기 어려움이 있다. 그래서 전위 표기법, 후위 표기법으로 변환한 후에 계산을 진행한다.

전위 표기법

전위 표기법(prefix) : 연산자를 먼저, 피연산자를 나중에 표기하는 방식
중위 표기법에서 전위 표기법 변환 (중위 표기법 : 1+2/3*(4+5))
1. 연산자 우선순위에 맞게 소괄호로 묶는다. (1+((2/3)*(4+5)))
2. 괄호 안에 있는 연산자들을 앞으로 옮긴다. (+1(/*(23)+(45)))
3. 괄호들을 모두 없애준다. +1/*23+45

후위 표기법

후위 표기법(postfix) : 피연산자를 먼저, 연산자를 나중에 표기하는 방식
중위 표기법에서 후위 표기법 변환 (중위 표기법 : 1+2/3*(4+5))
1. 연산자 우선순위에 맞게 소괄호로 묶는다. (1+((2/3)*(4+5)))
2. 괄호 안에 있는 연산자들을 뒤로 옮긴다. (1((23)/(45))+*+)
3. 괄호들을 모두 없애준다. 123/45+*+
스택을 이용한 중위 표기법에서 후위 표기법 변환 및 계산
- 피연산자는 output에, 연산자는 operator stack(연산자 스택)에 push
- 탐색한 연산자가 operator stack top에 있는 연산자보다 우선순위가 같거나 낮은지 확인
- 우선순위가 같거나 낮다면 operator stack top에 있는 연산자를 pop하여 output에 push, operator stack에 탐색한 연산자를 push하는 방식
- 후위 표기법 계산은 왼쪽부터 stack에 쌓으면서 연산자가 탐색되면, stack에 쌓여있는 두 개의 피연산자를 pop하여 해당 연산 진행한 후 다시 stack에 push하는 방식
  - 연산1(2/3) => 연산2(4+5) => 연산3(연산1*연산2) => 연산4(연산3+1)

중위 표기법을 후위 표기법으로 변환 코드

const infix = `["1", "+", "2",  "/", "3", "*", "(", "4", "+", "5", ")"]`; // 중위 표기법

// 중위 표기법을 후위 표기법으로 전환
let output = [];
let operatorStack = [];
let operators = {
  "+": 1,
  "‑": 1,
  "*": 2,
  "/": 2,
  "%": 2,
  "^": 3, // 제곱 연산자
  "=": 0,
};

for (let i = 0; i < infix.length; i++) {
  let token = infix[i];

  if (!isNaN(Number(token || NaN))) { // 피연산자(숫자)인 경우 output에 push
    output.push(token);
  } else if (token in operators) { // 연산자인 경우
    while (
      operatorStack.length > 0 &&
      operators[operatorStack[operatorStack.length - 1]] >=
        operators[token] &&
      operatorStack[operatorStack.length - 1] !== "("
    ) { // operatorStack top에 연산자 우선순위가 token보다 높은 경우 pop하여 output에 push
      output.push(operatorStack.pop());
    }
    operatorStack.push(token); // operatorStack에 push
  } else if (token === "(") { // 여는 괄호인 경우 operatorStack에 push
    operatorStack.push(token);
  } else if (token === ")") { // 닫는 괄호인 경우 여는 괄호가 나오거나 operatorStack가 비워질 때까지 operatorStack에서 pop 후 output에 push
    while (
      operatorStack.length > 0 &&
      operatorStack[operatorStack.length - 1] !== "("
    ) {
      output.push(operatorStack.pop());
    }
    operatorStack.pop();
  }
}

while (operatorStack.length > 0) {  // operatorStack에 남아있는 연산자들을 output에 push
  output.push(operatorStack.pop());
}

후위 표기법 계산 코드

for (let i = 0; i < res.length; i++) {
  let token = res[i];
  if (!isNaN(Number(token))) { // 피연산자(숫자)인 경우 stack에 push
    stack.push(Number(token));
  } else { // 연산자인 경우 stack에 있는 두 개의 수를 pop하여, 해당 연산 수행 후 stack에 다시 push
    let operand2 = stack.pop();
    let operand1 = stack.pop();

    switch (token) {
      case "+":
        stack.push(operand1 + operand2);
        break;
      case "‑":
        stack.push(operand1 - operand2);
        break;
      case "*":
        stack.push(operand1 * operand2);
        break;
      case "/":
        stack.push(operand1 / operand2);
        break;
      case "%":
        stack.push(operand1 % operand2);
        break;
      case "^": // 제곱 연산자
        stack.push(operand1 ** operand2);
        break;
    }
  }
}

const answer = stack.pop(); // 후위 표기법 계산 결과

프로그래머스/Javascript : 기초 문제 22일차

Tue, 21 May 2024 16:14:40 +0900

0 떼기

문제

정수로 이루어진 문자열 n_str이 주어질 때, n_str의 가장 왼쪽에 처음으로 등장하는 0들을 뗀 문자열을 return하도록 solution 함수를 완성해주세요.

제한사항
- 2 ≤ n_str ≤ 10
- n_str이 "0"으로만 이루어진 경우는 없습니다.

소스 코드

const solution = (nStr) => {
  return String(Number(nStr));
};

두 수의 합

문제

0 이상의 두 정수가 문자열 a, b로 주어질 때, a + b의 값을 문자열로 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ a의 길이 ≤ 100,000
- 1 ≤ b의 길이 ≤ 100,000
- a와 b는 숫자로만 이루어져 있습니다.
- a와 b는 정수 0이 아니라면 0으로 시작하지 않습니다.

소스 코드

const solution = (a, b) => {
  return String(BigInt(a) + BigInt(b));
};

문자열로 변환

문제

정수 n이 주어질 때, n을 문자열로 변환하여 return하도록 solution 함수를 완성해주세요.

제한사항
- 1 ≤ n ≤ 10000

소스 코드

const solution = (n) => {
  return String(n);
};

배열의 원소 삭제하기

문제

정수 배열 arr과 delete_list가 있습니다. arr의 원소 중 delete_list의 원소를 모두 삭제하고 남은 원소들은 기존의 arr에 있던 순서를 유지한 배열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ arr의 길이 ≤ 100
- 1 ≤ arr의 원소 ≤ 1,000
- arr의 원소는 모두 서로 다릅니다.
- 1 ≤ delete_list의 길이 ≤ 100
- 1 ≤ delete_list의 원소 ≤ 1,000
- delete_list의 원소는 모두 서로 다릅니다.

소스 코드

const solution = (arr, deleteList) => {
  return arr.filter((num) => !deleteList.includes(num));
};

부분 문자열인지 확인하기

문제

부분 문자열이란 문자열에서 연속된 일부분에 해당하는 문자열을 의미합니다. 예를 들어, 문자열 "ana", "ban", "anana", "banana", "n"는 모두 문자열 "banana"의 부분 문자열이지만, "aaa", "bnana", "wxyz"는 모두 "banana"의 부분 문자열이 아닙니다.

문자열 my_string과 target이 매개변수로 주어질 때, target이 문자열 my_string의 부분 문자열이라면 1을, 아니라면 0을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ my_string의 길이 ≤ 100
- my_string은 영소문자로만 이루어져 있습니다.
- 1 ≤ target의 길이 ≤ 100
- target은 영소문자로만 이루어져 있습니다.

소스 코드

const solution = (myString, target) => {
  return myString.includes(target) ? 1 : 0;
};

Javascript : 이벤트와 이벤트 위임

Tue, 21 May 2024 11:38:51 +0900

이벤트

이벤트: DOM에서 발생한 어떤 사건(클릭, 입력 등)으로 이벤트를 통해 원하는 동작을 할 수 있음
이벤트 흐름: target에 이벤트가 발생하는 경우 상위부터 target으로, target부터 다시 상위로 이벤트가 발생하며, catch를 하여 이벤트에 대한 원하는 동작을 설정할 수 있음
- Bubbling: target에서 이벤트가 발생하면 target 이벤트가 동작하고, 상위 요소 핸들러가 순차적으로 동작
- Capturing: target에서 이벤트가 발생하면 최상위 요소에서부터 target으로 순차적으로 이벤트 동작
- addEventListener(type, listener, useCapture);
  - type: 이벤트 유형(click, mousemove, mousedown 등)
  - listener: 이벤트를 수신할 객체로, 콜백 함수 또는 handleEvent() 메서드를 포함하는 객체
  - option: 이벤트 수신기 특징을 지정할 수 있는 객체
    - capture(기본값: false): false시 bubbling, true시 catpturing으로 설정
    - once(기본값: false): 수신기 최대 한 번 동작하도록 설정
    - passive: 수신기 내 preventDefault()를 호출하지 않는 여부

이벤트 위임

이벤트 위임: 하위 모든 요소에 이벤트를 등록하지 않고, 상위 요소 한 개에 이벤트를 등록

addEventListener를 여러 번 호출하는 것을 방지하기 때문에 성능 향상과 유지 보수에 좋음

<html>
    <body>
        <ul>
            <li>1</li>
            <li>2</li>
            <li>3</li>
        </ul>
        <script>
          // 이벤트 위임을 사용하지 않을 경우, addEventListener이 세 번 호출 됨
            // for (const item of document.querySelectorAll("li")) {
            //   item.addEventListener("click", (e) => {
            //      console.log(e.target.innerText);
            //   });
            // }
            
            // 이벤트 위임을 사용한 코드
            const list = document.querySelector("ul");

            list.addEventListener("click", (e) => {
                if (e.target.tagName === "LI") {
                    console.log(e.target.innerText);
                }
            });
        </script>
    </body>
</html>

이벤트 관련 함수

event.preventDefault(): target의 고유한 동작을 중지 시키는 함수
event.stopPropagation(): target의 이벤트가 상위 요소로 전달되는 것을 방지, 즉 버블링을 중단시키는 함수

Typescript : 타입스크립트 언어의 특징과 장단점

Tue, 21 May 2024 09:37:03 +0900

Typescript

타입스크립트(Typescript): Microsoft에서 개발한 자바스크립트(Javascript) 기반 언어
- 정적 타입 언어: 자바스크립트에 정적 타입 문법을 추가한 상위 언어, 반면 자바스크립트는 런타임에 따라 결정되는 동적 타입 언어
```
// 타입을 명시적으로 선언
const foo: string;
const bar: number;
const baz: boolean;
```
- 컴파일 언어: 자바스크립트로 컴파일 과정을 거친 후 실행할 수 있음, 반면 자바스크립트는 코드를 읽어가며 명령을 바로 처리하는 인터프리터 언어
- 그 외 Generic, Enum, Interface 등의 기능들이 있음

타입스크립트 장단점

장점
- 타입(Type) 시스템: 컴파일 과정에서 타입을 사용하기 때문에 에러를 예방할 수 있으며, 디버깅이 가능함
- 높은 생산성: 객체 필드나 함수 매개변수로 들어오는 변수의 이름과 자료형 확인을 쉽게 할 수 있어, 자바스크립트보다 코드 작성을 쉽고 직관적으로 할 수 있음
- 자바스크립트의 슈퍼셋: 자바스크립트 프로젝트 코드를 수정하여, 타입스크립트로 점진적으로 적용할 수 있음
  - 슈퍼셋(Superset): 특정한 언어의 모든 기능을 포함하면서, 다른 기능까지 포함하도록 향상 또는 확장된 것
단점
- 초기 세팅이 어려움: 자바스크립트 엔진에서 실행되기 때문에, 따로 설치해야하는 모듈이나 컴파일을 위한 옵션(tsconfig.json)을 설정해주어야 함
- 타입 지정으로 인한 생산성 저하: 타입의 지정이나, interface, class등에 익숙하지 않은 경우 생산성이 저하될 수 있음

참고 자료

Javascript : 프로토타입과 this, call, apply, bind

Thu, 09 May 2024 13:28:15 +0900

프로토타입

javascript에는 클래스라는 개념이 없기 때문에, 자신이 다른 객체의 원형이 되는 객체를 의미

// Person에 대한 프로토타입 생성
function Person() {
  this.name;
  this.age;
  this.job;
}

// Person 프로토타입에 대한 setData 함수 생성
Person.prototype.setData = (name, age, job) => {
  this.name = name;
  this.age = age;
  this.job = job;
};

// Person 프로토타입에 대한 setData 함수 생성
Person.prototype.introduce = (name, age, job) => {
  console.log(
    `"안녕하세요 저는 ${this.name}이라고 합니다! 나이는 ${this.age}이고, 직업은 ${this.job}입니다."`
  );
};

// Person에 대한 객체 생성(pdh 기준으로 상위 객체는 Person)
const pdh = new Person();
pdh.setData("DongHun Park", "26", "programmer");
pdh.introduce();

프로토타입 체인: 생성된 객체가 프로토타입(객체)과 체인에 걸려있는 것처럼 연결된 형태

this

this: 객체의 함수에서 호출한 객체를 가리키는 키워드
- 호출한 객체가 없을 경우, default는 window

...

// (2) pdh 객체가 introduce 함수를 호출할 경우, this 객체는 pdh
Person.prototype.introduce = (name, age, job) => {
  console.log(
    `"안녕하세요 저는 ${this.name}이라고 합니다! 나이는 ${this.age}이고, 직업은 ${this.job}입니다."`
  );
};

...
// (1) pdh 객체가 introduce 함수를 호출
pdh.introduce();

call, apply, bind

프로토타입 함수에 대해 this를 직접 지정해 주는 기능을 하는 함수
call: 함수를 바로 호출하면서 매개변수에 인자를 하나씩 전달
apply: 함수를 바로 호출하면서 매개변수를 배열 값으로 전달
bind: 함수를 바로 호출하지 않고, 매개변수를 바인딩한 새로운 함수를 반환

...

Person.prototype.introduce = (name, age, job) => {
  console.log(
    `"안녕하세요 저는 ${this.name}이라고 합니다! 나이는 ${this.age}이고, 직업은 ${this.job}입니다."`
  );
};

const pdh = new Person();
pdh.setData("DongHun Park", "26", "programmer");

// pdh객체를 넣은 상태에서 introduce 함수를 바로 실행
introduce.call(pdh);

// pdh객체를 넣은 상태에서 introduce 함수 바인딩
const introducePDH = introduce.bind(pdh)
introducePDH; // 바인딩한 함수인 introducePDH 실행

Javascript : var, let, const, 스코프

Wed, 08 May 2024 13:02:09 +0900

var

var(variable): 데이터 타입을 지정할 필요가 없는 변수 선언 방식

함수 범위로 사용되며, 함수 또는 프로그램(전역)이 실행되면 생성되고, 종료되면 소멸되는 방식

var globalVar = "hello"; // 전역 변수

function show(){
    var localVar = "hi"; // 지역 변수

    console.log(localVar); // hi
    console.log(globalVar); // hello
}

console.log(localVar); // error undefined
console.log(globalVar); // hello

let, const

var 사용의 문제점
- 같은 이름으로 재정의 또는 재선언이 가능하며, 마지막 값으로 받는다.
```
//변수 선언
var x = "hello";

// 재정의
x = "world";

// 재선언
var x = "hello world";
```
- 함수 스코프이기 때문에, 함수(전역) 내에 있는 동일한 변수는 재선언이 가능
```
var say = "hello";
if (true) {
    var say = "hi";
}

console.log(say); // hi 
```
- 변수 선언하기 전에 참조할 경우 undefined를 반환(Hoisting)
  - Hoisting(호이스팅): 변수나 함수를 실행 이전(Runtime)에 미리 동작 시키거나 생성하는 것
```
console.log(say) // 호이스팅으로 인한 undefined 출력
var say = "hello";
console.log(say); // hello
```
let: 가변 변수로 재정의할 수 있지만, 재선언이 불가능
const: 불변 변수로 재정의하거나 재선언이 불가능
let와 const의 특징: 블록(block) 단위 스코프

스코프

스코프: 변수가 접근할 수 있는 유효 범위
전역 스코프: 코드 모든 곳에서 변수를 참조할 수 있음
지역 스코프: 코드 특정 부분에서만 사용 가능한 변수
함수 스코프: 함수를 기준으로 범위가 구분
블록 스코프: 중괄호를 기준으로 범위가 구분
스코프 규칙: 바깥쪽 스코프에서 안쪽 스코프로 접근할 수 있으나, 반대로는 불가능하며, 스코프는 중첩이 가능함
정적 스코프(렉시컬 스코프): 함수 선언 위치에 따라 상위 스코프가 결정, javascript의 특징
동적 스코프: 함수 호출 위치에 따라 상위 스코프가 결정

프로그래머스/Javascript : 기초 문제 21일차

Fri, 12 Apr 2024 02:04:35 +0900

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

문제

정수 배열 arr이 매개변수로 주어집니다. arr의 길이가 2의 정수 거듭제곱이 되도록 arr 뒤에 정수 0을 추가하려고 합니다. arr에 최소한의 개수로 0을 추가한 배열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ arr의 길이 ≤ 1,000
- 1 ≤ arr의 원소 ≤ 1,000

소스 코드

const solution = arr => {
  let length = arr.length;
  let answer = arr;
  let count = 0;

  while (true) {
    length = Math.round(length / 2);

    if (length === 1) {
      break;
    }
    count++;
  }

  if (2 ** count < arr.length) {
    for (let i = arr.length; i < 2 ** (count + 1); i++) {
      answer.push(0);
    }
  }

  return answer;
};

두 배열의 길이가 다르다면, 배열의 길이가 긴 쪽이 더 큽니다. 배열의 길이가 같다면 각 배열에 있는 모든 원소의 합을 비교하여 다르다면 더 큰 쪽이 크고, 같다면 같습니다. 두 정수 배열 arr1과 arr2가 주어질 때, 위에서 정의한 배열의 대소관계에 대하여 arr2가 크다면 -1, arr1이 크다면 1, 두 배열이 같다면 0을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ arr1의 길이 ≤ 100
- 1 ≤ arr2의 길이 ≤ 100
- 1 ≤ arr1의 원소 ≤ 100
- 1 ≤ arr2의 원소 ≤ 100
문제에서 정의한 배열의 대소관계가 일반적인 프로그래밍 언어에서 정의된 배열의 대소관계와 다를 수 있는 점에 유의해주세요.

소스 코드

const solution = (arr1, arr2) => {
  if (arr1.length > arr2.length) {
    return 1;
  } else if (arr1.length < arr2.length) {
    return -1;
  } else {
    const arr1Sum = arr1.reduce((acc, cur) => acc + cur, 0);
    const arr2Sum = arr2.reduce((acc, cur) => acc + cur, 0);
    if (arr1Sum > arr2Sum) {
      return 1;
    } else if (arr1Sum < arr2Sum) {
      return -1;
    } else {
      return 0;
    }
  }
};

문자열 묶기

문제

문자열 배열 strArr이 주어집니다. strArr의 원소들을 길이가 같은 문자열들끼리 그룹으로 묶었을 때 가장 개수가 많은 그룹의 크기를 return 하는 solution 함수를 완성해 주세요.

제한사항
- 1 ≤ strArr의 길이 ≤ 100,000
  - 1 ≤ strArr의 원소의 길이 ≤ 30
  - strArr의 원소들은 알파벳 소문자로 이루어진 문자열입니다.

소스 코드

const solution = (strArr) => {
  const arr = {};
  strArr.map(str => {
    if (!arr[str.length]) {
      arr[str.length] = [];
    }
    arr[str.length].push(str);
  });
  return Math.max(...Object.values(arr).map(arr => arr.length));
};

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

문제

정수 배열 arr과 정수 n이 매개변수로 주어집니다. arr의 길이가 홀수라면 arr의 모든 짝수 인덱스 위치에 n을 더한 배열을, arr의 길이가 짝수라면 arr의 모든 홀수 인덱스 위치에 n을 더한 배열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ arr의 길이 ≤ 1,000
- 1 ≤ arr의 원소 ≤ 1,000 -1 ≤ n ≤ 1,000

소스 코드

const solution = (arr, n) => {
  if (arr.length % 2 === 0) {
    return arr.map((item, index) => index % 2 === 0 ? item : item + n);
  } else {
    return arr.map((item, index) => index % 2 === 1 ? item : item + n);
  }
};

뒤에서 5등까지

문제

정수로 이루어진 리스트 num_list가 주어집니다. num_list에서 가장 작은 5개의 수를 오름차순으로 담은 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항
- 6 ≤ num_list의 길이 ≤ 30
- 1 ≤ num_list의 원소 ≤ 100

소스 코드

const solution = (numList) => {
  return numList.sort((a, b) => a - b)
    .filter((num, index) => index < 5);
};

프로그래머스/Javascript : 기초 문제 20일차

Wed, 10 Apr 2024 01:33:56 +0900

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

문제

제한사항
- 1 ≤ arr의 길이 ≤ 1,000
- 1 ≤ arr의 원소 ≤ 1,000

소스 코드

const solution = arr => {
  let length = arr.length;
  let answer = arr;
  let count = 0;

  while (true) {
    length = Math.round(length / 2);

    if (length === 1) {
      break;
    }
    count++;
  }

  if (2 ** count < arr.length) {
    for (let i = arr.length; i < 2 ** (count + 1); i++) {
      answer.push(0);
    }
  }

  return answer;
};

배열 비교하기

문제

이 문제에서 두 정수 배열의 대소관계를 다음과 같이 정의합니다.

제한사항
- 1 ≤ arr1의 길이 ≤ 100
- 1 ≤ arr2의 길이 ≤ 100
- 1 ≤ arr1의 원소 ≤ 100
- 1 ≤ arr2의 원소 ≤ 100
문제에서 정의한 배열의 대소관계가 일반적인 프로그래밍 언어에서 정의된 배열의 대소관계와 다를 수 있는 점에 유의해주세요.

소스 코드

const solution = (arr1, arr2) => {
  if (arr1.length > arr2.length) {
    return 1;
  } else if (arr1.length < arr2.length) {
    return -1;
  } else {
    const arr1Sum = arr1.reduce((acc, cur) => acc + cur, 0);
    const arr2Sum = arr2.reduce((acc, cur) => acc + cur, 0);
    if (arr1Sum > arr2Sum) {
      return 1;
    } else if (arr1Sum < arr2Sum) {
      return -1;
    } else {
      return 0;
    }
  }
};

문자열 묶기

문제

제한사항
- 1 ≤ strArr의 길이 ≤ 100,000
  - 1 ≤ strArr의 원소의 길이 ≤ 30
  - strArr의 원소들은 알파벳 소문자로 이루어진 문자열입니다.

소스 코드

const solution = (strArr) => {
  const arr = {};
  strArr.map(str => {
    if (!arr[str.length]) {
      arr[str.length] = [];
    }
    arr[str.length].push(str);
  });
  return Math.max(...Object.values(arr).map(arr => arr.length));
};

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

문제

제한사항
- 1 ≤ arr의 길이 ≤ 1,000
- 1 ≤ arr의 원소 ≤ 1,000
- 1 ≤ n ≤ 1,000

소스 코드

const solution = (arr, n) => {
  if (arr.length % 2 === 0) {
    return arr.map((item, index) => index % 2 === 0 ? item : item + n);
  } else {
    return arr.map((item, index) => index % 2 === 1 ? item : item + n);
  }
};

뒤에서 5등까지

문제

정수로 이루어진 리스트 num_list가 주어집니다. num_list에서 가장 작은 5개의 수를 오름차순으로 담은 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항
- 6 ≤ num_list의 길이 ≤ 30
- 1 ≤ num_list의 원소 ≤ 100

소스 코드

const solution = (numList) => {
  return numList.sort((a, b) => a - b)
    .filter((num, index) => index < 5);
};

프로그래머스/Javascript : 기초 문제 19일차

Mon, 08 Apr 2024 01:26:28 +0900

세 개의 구분자

문제

임의의 문자열이 주어졌을 때 문자 "a", "b", "c"를 구분자로 사용해 문자열을 나누고자 합니다.

예를 들어 주어진 문자열이 "baconlettucetomato"라면 나눠진 문자열 목록은 ["onlettu", "etom", "to"] 가 됩니다.

문자열 myStr이 주어졌을 때 위 예시와 같이 "a", "b", "c"를 사용해 나눠진 문자열을 순서대로 저장한 배열을 return 하는 solution 함수를 완성해 주세요.

단, 두 구분자 사이에 다른 문자가 없을 경우에는 아무것도 저장하지 않으며, return할 배열이 빈 배열이라면 ["EMPTY"]를 return 합니다.

제한사항
- 1 ≤ myStr의 길이 ≤ 1,000,000
  - myStr은 알파벳 소문자로 이루어진 문자열 입니다.

소스 코드

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

let myStr = [];

rl.on('line', (line) => {
  myStr = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(myStr);
  console.log(answer);
});

const solution = myStr => {
  let answer = [];
  let str = '';
  for (let i = 0; i < myStr.length; i++) {
    if (!['a', 'b', 'c'].includes(myStr[i])) {
      str += myStr[i];
    } else {
      if (str !== '') {
        answer.push(str);
      }
      str = '';
    }
  }
  if (str !== '') {
    answer.push(str);
  }

  return answer.length === 0 ? ["EMPTY"] : answer;
};

배열의 원소만큼 추가하기

문제

아무 원소도 들어있지 않은 빈 배열 X가 있습니다. 양의 정수 배열 arr가 매개변수로 주어질 때, arr의 앞에서부터 차례대로 원소를 보면서 원소가 a라면 X의 맨 뒤에 a를 a번 추가하는 일을 반복한 뒤의 배열 X를 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ arr의 길이 ≤ 100
- 1 ≤ arr의 원소 ≤ 100

소스 코드

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

let arr = [];

rl.on('line', (line) => {
  arr = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(arr);
  console.log(answer);
});

const solution = arr => {
  let answer = [];
  for (let i = 0; i < arr.length; i++) {
    for (let j = 0; j < arr[i]; j++) {
      answer.push(arr[i]);
    }
  }
  return answer;
};

빈 배열에 추가, 삭제하기

문제

아무 원소도 들어있지 않은 빈 배열 X가 있습니다. 길이가 같은 정수 배열 arr과 boolean 배열 flag가 매개변수로 주어질 때, flag를 차례대로 순회하며 flag[i]가 true라면 X의 뒤에 arr[i]를 arr[i] × 2 번 추가하고, flag[i]가 false라면 X에서 마지막 arr[i]개의 원소를 제거한 뒤 X를 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ arr의 길이 = flag의 길이 ≤ 100
- arr의 모든 원소는 1 이상 9 이하의 정수입니다.
- 현재 X의 길이보다 더 많은 원소를 빼는 입력은 주어지지 않습니다.

소스 코드

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

let arr = [];
let flag = [];
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    arr = line.split(' ').map(Number);
  } else {
    flag = line.split(' ').map(Number).map(item => item === 1);
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(arr, flag);
  console.log(answer);
});

const solution = (arr, flag) => {
  let answer = [];
  for (let i = 0; i < arr.length; i++) {
    if (flag[i]) {
       for (let j = 0; j < arr[i] * 2; j++) {
         answer.push(arr[i]);
       }
    } else {
      answer.splice(answer.length - arr[i], answer.length);
    }
  }

  return answer;
};

배열 만들기 6

문제

0과 1로만 이루어진 정수 배열 arr가 주어집니다. arr를 이용해 새로운 배열 stk을 만드려고 합니다.

i의 초기값을 0으로 설정하고 i가 arr의 길이보다 작으면 다음을 반복합니다.

만약 stk이 빈 배열이라면 arr[i]를 stk에 추가하고 i에 1을 더합니다. stk에 원소가 있고, stk의 마지막 원소가 arr[i]와 같으면 stk의 마지막 원소를 stk에서 제거하고 i에 1을 더합니다. stk에 원소가 있는데 stk의 마지막 원소가 arr[i]와 다르면 stk의 맨 마지막에 arr[i]를 추가하고 i에 1을 더합니다. 위 작업을 마친 후 만들어진 stk을 return 하는 solution 함수를 완성해 주세요.

단, 만약 빈 배열을 return 해야한다면 [-1]을 return 합니다.

제한사항
- 1 ≤ arr의 길이 ≤ 1,000,000
  - arr의 원소는 0 또는 1 입니다.

소스 코드

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

let arr = [];

rl.on('line', (line) => {
  arr = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(arr);
  console.log(answer);
});

const solution = arr => {
  let answer = [arr[0]];
  let number = arr[0];
  for (let i = 1; i < arr.length; i++) {
    if (answer[answer.length - 1] !== arr[i]) {
      answer.push(arr[i]);
    } else {
      answer.splice(answer.length - 1, answer.length);
    }

    number = arr[i];
  }

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

무작위로 K개의 수 뽑기

문제

랜덤으로 서로 다른 k개의 수를 저장한 배열을 만드려고 합니다. 적절한 방법이 떠오르지 않기 때문에 일정한 범위 내에서 무작위로 수를 뽑은 후, 지금까지 나온적이 없는 수이면 배열 맨 뒤에 추가하는 방식으로 만들기로 합니다.

이미 어떤 수가 무작위로 주어질지 알고 있다고 가정하고, 실제 만들어질 길이 k의 배열을 예상해봅시다.

정수 배열 arr가 주어집니다. 문제에서의 무작위의 수는 arr에 저장된 순서대로 주어질 예정이라고 했을 때, 완성될 배열을 return 하는 solution 함수를 완성해 주세요.

단, 완성될 배열의 길이가 k보다 작으면 나머지 값을 전부 -1로 채워서 return 합니다.

제한사항
- 1 ≤ arr의 길이 ≤ 100,000
  - 0 ≤ arr의 원소 ≤ 100,000
- 1 ≤ k ≤ 1,000

소스 코드

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

let arr = [];
let k = 0;
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    arr = line.split(' ').map(Number);
  } else {
    k = Number(line);
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(arr, k);
  console.log(answer);
});

const solution = (arr, k) => {
  let answer = [];
  let set = [...new Set(arr)];

  for (let i = 0; i < k; i++) {
    if (set[i] !== undefined) {
      answer.push(set[i]);
    } else {
      answer.push(-1);
    }
  }

  return answer;
};

프로그래머스/Javascript : 기초 문제 18일차

Wed, 27 Mar 2024 00:32:23 +0900

x 사이의 개수

문제

문자열 myString이 주어집니다. myString을 문자 "x"를 기준으로 나눴을 때 나눠진 문자열 각각의 길이를 순서대로 저장한 배열을 return 하는 solution 함수를 완성해 주세요.

제한사항
- 1 ≤ myString의 길이 ≤ 100,000
  - myString은 알파벳 소문자로 이루어진 문자열입니다.

소스 코드

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

let myString = '';

rl.on('line', (line) => {
  myString = line;
  rl.close();
}).on('close', () => {
  const answer = solution(myString);
  console.log(answer);
});

const solution = myString => {
  let answer = [];
  let count = 0;

  for (let i = 0; i < myString.length; i++) {
    if (myString[i] !== 'x') {
      count++;
    } else {
      answer.push(count);
      count = 0;
    }
  }
  answer.push(count);

  return answer;
};

문자열 잘라서 정렬하기

문제

제한사항
- 1 ≤ myString의 길이 ≤ 100,000
  - myString은 알파벳 소문자로 이루어진 문자열입니다.

소스 코드

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

let myString = '';

rl.on('line', (line) => {
  myString = line;
  rl.close();
}).on('close', () => {
  const answer = solution(myString);
  console.log(answer);
});

const solution = myString => {
  let answer = [];
  let str = '';

  for (let i = 0; i < myString.length; i++) {
    if (myString[i] !== 'x') {
      str += myString[i];
    } else {
      if (str !== '') {
        answer.push(str);
        str = '';
      }
    }
  }
  if (str !== '') {
    answer.push(str);
  }

  return answer.sort();
};

간단한 식 계산하기

문제

문자열 binomial이 매개변수로 주어집니다. binomial은 "a op b" 형태의 이항식이고 a와 b는 음이 아닌 정수, op는 '+', '-', '*' 중 하나입니다. 주어진 식을 계산한 정수를 return 하는 solution 함수를 작성해 주세요.

제한사항
- 0 ≤ a, b ≤ 40,000
- 0을 제외하고 a, b는 0으로 시작하지 않습니다.

소스 코드

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

let binomial = '';

rl.on('line', (line) => {
  binomial = line;
  rl.close();
}).on('close', () => {
  const answer = solution(binomial);
  console.log(answer);
});

const solution = binomial => {
  const calcString = binomial.split(' ');
  if (calcString[1] === '+') {
    return parseInt(calcString[0]) + parseInt(calcString[2]);
  } else if (calcString[1] === '-') {
    return parseInt(calcString[0]) - parseInt(calcString[2]);
  } else if (calcString[1] === '*') {
    return parseInt(calcString[0]) * parseInt(calcString[2]);
  } else if (calcString[1] === '/')
    return parseInt(calcString[0]) / parseInt(calcString[2]);
};

문자열 바꿔서 찾기

문제

문자 "A"와 "B"로 이루어진 문자열 myString과 pat가 주어집니다. myString의 "A"를 "B"로, "B"를 "A"로 바꾼 문자열의 연속하는 부분 문자열 중 pat이 있으면 1을 아니면 0을 return 하는 solution 함수를 완성하세요.

제한사항
- 1 ≤ myString의 길이 ≤ 100
- 1 ≤ pat의 길이 ≤ 10
  - myString과 pat는 문자 "A"와 "B"로만 이루어진 문자열입니다.

소스 코드

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

let myString = '';
let pat = '';
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    myString = line;
  } else {
    pat = line;
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(myString, pat);
  console.log(answer);
});

const solution = (myString, pat) => {
  const reverseString = myString.split('').map((char) => char === 'A' ? 'B' : 'A').join('');
  for (let i = 0; i <= reverseString.length - pat.length; i++) {
    if (pat === reverseString.substring(i, i + pat.length)) {
      return 1;
    }
  }

  return 0;
};

rny_string

문제

'm'과 "rn"이 모양이 비슷하게 생긴 점을 활용해 문자열에 장난을 하려고 합니다. 문자열 rny_string이 주어질 때, rny_string의 모든 'm'을 "rn"으로 바꾼 문자열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ rny_string의 길이 ≤ 100
- rny_string은 영소문자로만 이루어져 있습니다.

소스 코드

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

let rnyString = '';

rl.on('line', (line) => {
  rnyString = line;
  rl.close();
}).on('close', () => {
  const answer = solution(rnyString);
  console.log(answer);
});

const solution = rnyString => {
  return rnyString.split('').map(str => str === 'm' ? 'rn' : str).join('');
};

프로그래머스/Javascript : 기초 문제 17일차

Sun, 24 Mar 2024 02:28:21 +0900

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

문제

문자열 myString과 pat가 주어집니다. myString의 부분 문자열중 pat로 끝나는 가장 긴 부분 문자열을 찾아서 return 하는 solution 함수를 완성해 주세요.

제한사항
- 5 ≤ myString ≤ 20
- 1 ≤ pat ≤ 5
  - pat은 반드시 myString의 부분 문자열로 주어집니다.
- myString과 pat에 등장하는 알파벳은 대문자와 소문자를 구분합니다.

소스 코드

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

let myString = '';
let pat = '';
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    myString = line;
  } else {
    pat = line;
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(myString, pat);
  console.log(answer);
});

const solution = (myString, pat) => {
  for (let i = myString.length + 1 - pat.length; i >= 0; i--) {
    if (pat === myString.substring(i, i + pat.length)) {
      return myString.substring(0, i + pat.length);
    }
  }
};

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

문제

문자열 myString과 pat이 주어집니다. myString에서 pat이 등장하는 횟수를 return 하는 solution 함수를 완성해 주세요.

제한사항
- 1 ≤ myString ≤ 1000
- 1 ≤ pat ≤ 10

소스 코드

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

let myString = '';
let pat = '';
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    myString = line;
  } else {
    pat = line;
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(myString, pat);
  console.log(answer);
});

const solution = (myString, pat) => {
  let count = 0;
  for (let i = myString.length + 1 - pat.length; i >= 0; i--) {
    if (pat === myString.substring(i, i + pat.length)) {
      count++;
    }
  }

  return count;
};

ad 제거하기

문제

문자열 배열 strArr가 주어집니다. 배열 내의 문자열 중 "ad"라는 부분 문자열을 포함하고 있는 모든 문자열을 제거하고 남은 문자열을 순서를 유지하여 배열로 return 하는 solution 함수를 완성해 주세요.

제한사항
- 1 ≤ strArr의 길이 ≤ 1,000
  - 1 ≤ strArr의 원소의 길이 ≤ 20
  - strArr의 원소는 알파벳 소문자로 이루어진 문자열입니다.

소스 코드

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

let strArr = '';

rl.on('line', (line) => {
  strArr = line;
  rl.close();
}).on('close', () => {
  const answer = solution(strArr);
  console.log(answer);
});

const solution = strArr => {
  return strArr.filter(str => !str.includes('ad'));
};

공백으로 구분하기 1

문제

단어가 공백 한 개로 구분되어 있는 문자열 my_string이 매개변수로 주어질 때, my_string에 나온 단어를 앞에서부터 순서대로 담은 문자열 배열을 return 하는 solution 함수를 작성해 주세요.

소스 코드

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

let myString = '';

rl.on('line', (line) => {
  myString = line;
  rl.close();
}).on('close', () => {
  const answer = solution(strArr);
  console.log(answer);
});

const solution = myString => {
  return myString.split(' ');
};

공백으로 구분하기 2

문제

단어가 공백 한 개 이상으로 구분되어 있는 문자열 my_string이 매개변수로 주어질 때, my_string에 나온 단어를 앞에서부터 순서대로 담은 문자열 배열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- my_string은 영소문자와 공백으로만 이루어져 있습니다.
- 1 ≤ my_string의 길이 ≤ 1,000
- my_string의 맨 앞과 맨 뒤에도 공백이 있을 수 있습니다.
- my_string에는 단어가 하나 이상 존재합니다.

소스 코드

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

let myString = '';

rl.on('line', (line) => {
  myString = line;
  rl.close();
}).on('close', () => {
  const answer = solution(myString);
  console.log(answer);
});

const solution = myString => {
  return myString.replace(/ +/g, ' ')
    .split(' ')
    .filter(str => str !== '');
};

프로그래머스/Javascript : 기초 문제 16일차

Sat, 23 Mar 2024 00:43:15 +0900

대문자로 바꾸기

문제

알파벳으로 이루어진 문자열 myString이 주어집니다. 모든 알파벳을 대문자로 변환하여 return 하는 solution 함수를 완성해 주세요.

제한사항
- 1 ≤ myString의 길이 ≤ 100,000
  - myString은 알파벳으로 이루어진 문자열입니다.

소스 코드

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

let myString = '';

rl.on('line', (line) => {
  myString = line;
  rl.close();
}).on('close', () => {
  const answer = solution(myString);
  console.log(answer);
});

const solution = myString => {
  return myString.toUpperCase()
};

소문자로 바꾸기

문제

알파벳으로 이루어진 문자열 myString이 주어집니다. 모든 알파벳을 소문자로 변환하여 return 하는 solution 함수를 완성해 주세요.

제한사항
- 1 ≤ myString의 길이 ≤ 100,000
  - myString은 알파벳으로 이루어진 문자열입니다.

소스 코드

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

let myString = '';

rl.on('line', (line) => {
  myString = line;
  rl.close();
}).on('close', () => {
  const answer = solution(myString);
  console.log(answer);
});

const solution = myString => {
  return myString.toLowerCase()
};

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

문제

문자열 배열 strArr가 주어집니다. 모든 원소가 알파벳으로만 이루어져 있을 때, 배열에서 홀수번째 인덱스의 문자열은 모든 문자를 대문자로, 짝수번째 인덱스의 문자열은 모든 문자를 소문자로 바꿔서 반환하는 solution 함수를 완성해 주세요.

제한사항
- 1 ≤ strArr ≤ 20
  - 1 ≤ strArr의 원소의 길이 ≤ 20
  - strArr의 원소는 알파벳으로 이루어진 문자열 입니다.

소스 코드

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

let myString = '';
let alp = '';
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    myString = line;
  } else {
    alp = line;
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(myString, pat);
  console.log(answer);
});

const solution = (myString, alp) => {
  let array = '';
  for (let i = 0; i < myString.length; i++) {
    if (myString[i].includes(alp)) {
      array += myString[i].toUpperCase();
    } else {
      array += myString[i];
    }
  }

  return array;
};

A 강조하기

문제

문자열 myString이 주어집니다. myString에서 알파벳 "a"가 등장하면 전부 "A"로 변환하고, "A"가 아닌 모든 대문자 알파벳은 소문자 알파벳으로 변환하여 return 하는 solution 함수를 완성하세요.

제한사항
- 1 ≤ myString의 길이 ≤ 20
  - myString은 알파벳으로 이루어진 문자열입니다.

소스 코드

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

let myString = '';

rl.on('line', (line) => {
  myString = line;
  rl.close();
}).on('close', () => {
  const answer = solution(myString);
  console.log(answer);
});

const solution = myString => {
  let array = '';
  for (let i = 0; i < myString.length; i++) {
    if (myString[i].includes('a')) {
      array += myString[i].toUpperCase();
    } else if (!myString[i].includes('A')) {
      array += myString[i].toLowerCase();
    } else {
      array += myString[i];
    }
  }

  return array;
};

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

문제

영소문자로 이루어진 문자열 my_string과 영소문자 1글자로 이루어진 문자열 alp가 매개변수로 주어질 때, my_string에서 alp에 해당하는 모든 글자를 대문자로 바꾼 문자열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ my_string의 길이 ≤ 1,000

소스 코드

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

let myString = '';
let alp = '';
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    myString = line;
  } else {
    alp = line;
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(myString, pat);
  console.log(answer);
});

const solution = (myString, alp) => {
  let array = '';
  for (let i = 0; i < myString.length; i++) {
    if (myString[i].includes(alp)) {
      array += myString[i].toUpperCase();
    } else {
      array += myString[i];
    }
  }

  return array;
};

프로그래머스/Javascript : 기초 문제 15일차

Fri, 22 Mar 2024 02:25:33 +0900

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

문제

정수 배열 arr가 주어집니다. arr의 각 원소에 대해 값이 50보다 크거나 같은 짝수라면 2로 나누고, 50보다 작은 홀수라면 2를 곱합니다. 그 결과인 정수 배열을 return 하는 solution 함수를 완성해 주세요.

제한사항
- 1 ≤ arr의 길이 ≤ 1,000,000
  - 1 ≤ arr의 원소의 값 ≤ 100

소스 코드

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

let arr = '';

rl.on('line', (line) => {
  arr = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(arr);
  console.log(answer);
});

const solution = arr => {
  let answer = [];
  for (const item of arr) {
    if (item >= 50 && item % 2 === 0) {
      answer.push(item / 2);
    } else if (item < 50 && item % 2 === 1) {
      answer.push(item * 2);
    } else {
      answer.push(item);
    }
  }

  return answer;
};

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

문제

정수 배열 arr가 주어집니다. arr의 각 원소에 대해 값이 50보다 크거나 같은 짝수라면 2로 나누고, 50보다 작은 홀수라면 2를 곱하고 다시 1을 더합니다.

이러한 작업을 x번 반복한 결과인 배열을 arr(x)라고 표현했을 때, arr(x) = arr(x + 1)인 x가 항상 존재합니다. 이러한 x 중 가장 작은 값을 return 하는 solution 함수를 완성해 주세요.

단, 두 배열에 대한 "="는 두 배열의 크기가 서로 같으며, 같은 인덱스의 원소가 각각 서로 같음을 의미합니다.

제한사항
- 1 ≤ arr의 길이 ≤ 1,000,000
  - 1 ≤ arr의 원소의 값 ≤ 100

소스 코드

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

let arr = '';

rl.on('line', (line) => {
  arr = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(arr);
  console.log(answer);
});

const solution = arr => {
  let tempArray = [...arr];
  let array = arr;
  let count = 0;

  while (true) {
    for (let index in array) {
      if (array[index] >= 50 && array[index] % 2 === 0) {
        array[index] = array[index] / 2;
      } else if (array[index] < 50 && array[index] % 2 === 1) {
        array[index] = array[index] * 2 + 1;
      } else {
        array[index] = array[index];
      }
    }

    console.log(JSON.stringify(tempArray), JSON.stringify(array))
    if (JSON.stringify(tempArray) === JSON.stringify(array)) {
      return count;
    }
    tempArray = [...array];
    count++;
  }
};

1로 만들기

문제

정수가 있을 때, 짝수라면 반으로 나누고, 홀수라면 1을 뺀 뒤 반으로 나누면, 마지막엔 1이 됩니다. 예를 들어 10이 있다면 다음과 같은 과정으로 1이 됩니다.

10 / 2 = 5 (5 - 1) / 2 = 2 2 / 2 = 1 위와 같이 3번의 나누기 연산으로 1이 되었습니다.

정수들이 담긴 리스트 num_list가 주어질 때, num_list의 모든 원소를 1로 만들기 위해서 필요한 나누기 연산의 횟수를 return하도록 solution 함수를 완성해주세요.

제한사항
- 3 ≤ num_list의 길이 ≤ 15
- 1 ≤ num_list의 원소 ≤ 30

소스 코드

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

let arr = '';

rl.on('line', (line) => {
  arr = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(arr);
  console.log(answer);
});

const solution = num_list => {
  let count = 0;
  for (let num of num_list) {
    while (num !== 1) {
      if (num % 2 === 0) {
        num = num / 2;
      } else {
        num = (num - 1) / 2;
      }
      count++;
    }
  }

  return count;
};

길이에 따른 연산

문제

10 / 2 = 5 (5 - 1) / 2 = 2 2 / 2 = 1 위와 같이 3번의 나누기 연산으로 1이 되었습니다.

제한사항
- 3 ≤ num_list의 길이 ≤ 15
- 1 ≤ num_list의 원소 ≤ 30

소스 코드

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

let arr = '';

rl.on('line', (line) => {
  arr = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(arr);
  console.log(answer);
});

const solution = num_list => {
  let answer = 0;
  if (num_list.length > 10) {
    for (const num of num_list) {
      answer += num;
    }
  } else {
    answer = 1;
    for (const num of num_list) {
      answer *= num;
    }
  }

  return answer;
};

원하는 문자열 찾기

문제

알파벳으로 이루어진 문자열 myString과 pat이 주어집니다. myString의 연속된 부분 문자열 중 pat이 존재하면 1을 그렇지 않으면 0을 return 하는 solution 함수를 완성해 주세요.

단, 알파벳 대문자와 소문자는 구분하지 않습니다.

제한사항
- 1 ≤ myString의 길이 ≤ 100,000
- 1 ≤ pat의 길이 ≤ 300
- myString과 pat은 모두 알파벳으로 이루어진 문자열입니다.

소스 코드

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

let myString = '';
let pat = '';
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    myString = line;
  } else {
    pat = line;
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(myString, pat);
  console.log(answer);
});

const solution = (myString, pat) => {
  if (myString.toLowerCase().includes(pat.toLowerCase())) {
    return 1;
  } else {
    return 0;
  }
};

프로그래머스/Javascript : 기초 문제 14일차

Wed, 20 Mar 2024 04:51:28 +0900

홀수 vs 짝수

문제

정수 리스트 num_list가 주어집니다. 가장 첫 번째 원소를 1번 원소라고 할 때, 홀수 번째 원소들의 합과 짝수 번째 원소들의 합 중 큰 값을 return 하도록 solution 함수를 완성해주세요. 두 값이 같을 경우 그 값을 return합니다.

제한사항
- 5 ≤ num_list의 길이 ≤ 50
- 9 ≤ num_list의 원소 ≤ 9

소스 코드

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

let num_list = [];

rl.on('line', (line) => {
  num_list = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(num_list);
  console.log(answer);
});

const solution = num_list => {
  let odd = 0;
  let even = 0;

  for (let i = 0; i < num_list.length; i++) {
    if (i % 2 === 0) {
      even += num_list[i];
    } else {
      odd += num_list[i];
    }
  }

  return even > odd ? even : odd;
};

5명씩

문제

최대 5명씩 탑승가능한 놀이기구를 타기 위해 줄을 서있는 사람들의 이름이 담긴 문자열 리스트 names가 주어질 때, 앞에서 부터 5명씩 묶은 그룹의 가장 앞에 서있는 사람들의 이름을 담은 리스트를 return하도록 solution 함수를 완성해주세요. 마지막 그룹이 5명이 되지 않더라도 가장 앞에 있는 사람의 이름을 포함합니다.

제한사항
- 5 ≤ names의 길이 ≤ 30
- 1 ≤ names의 원소의 길이 ≤ 10
- names의 원소는 영어 알파벳 소문자로만 이루어져 있습니다.

소스 코드

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

let names = [];

rl.on('line', (line) => {
  names = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(names);
  console.log(answer);
});

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

할 일 목록

문제

오늘 해야 할 일이 담긴 문자열 배열 todo_list와 각각의 일을 지금 마쳤는지를 나타내는 boolean 배열 finished가 매개변수로 주어질 때, todo_list에서 아직 마치지 못한 일들을 순서대로 담은 문자열 배열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ todo_list의 길이 1 ≤ 100
- 2 ≤ todo_list의 원소의 길이 ≤ 20
  - todo_list의 원소는 영소문자로만 이루어져 있습니다.
  - todo_list의 원소는 모두 서로 다릅니다.
- finished[i]는 true 또는 false이고 true는 todo_list[i]를 마쳤음을, false는 아직 마치지 못했음을 나타냅니다.
- 아직 마치지 못한 일이 적어도 하나 있습니다.

소스 코드

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

let todo_list = [];
let finished = [];
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    todo_list = line.split(' ');
  } else {
    finished = line.split(' ').map(Number).map(item => item === 1);
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(todo_list, finished);
  console.log(answer);
});

const 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보다 커질 때까지 더하기

문제

정수 배열 numbers와 정수 n이 매개변수로 주어집니다. numbers의 원소를 앞에서부터 하나씩 더하다가 그 합이 n보다 커지는 순간 이때까지 더했던 원소들의 합을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ numbers의 길이 ≤ 100
- 1 ≤ numbers의 원소 ≤ 100
- 0 ≤ n < numbers의 모든 원소의 합

소스 코드

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

let todo_list = [];
let finished = [];
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    todo_list = line.split(' ');
  } else {
    finished = line.split(' ').map(Number).map(item => item === 1);
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(todo_list, finished);
  console.log(answer);
});

const 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;
};

수열과 구간 쿼리 1

문제

제한사항
- 1 ≤ arr의 길이 ≤ 1,000
  - 0 ≤ arr의 원소 ≤ 1,000,000
- 1 ≤ queries의 길이 ≤ 1,000
  - 0 ≤ s≤ e < arr의 길이

소스 코드

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

let input = '';
let queries = '';
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    input = line.split(' ').map(Number);
  } else {
    queries = line.split(' ');
    queries = queries.map(item => {
      return item.split(',').map(Number);
    });
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(input, queries);
  console.log(answer);
});

const solution = (arr, queries) => {
  let answer = arr;
  for (let i = 0; i < queries.length; i++) {
    for (let j = queries[i][0]; j <= queries[i][1]; j++) {
      answer[j] += 1;
    }
  }

  return answer;
};

프로그래머스/Javascript : 기초 문제 13일차

Tue, 19 Mar 2024 02:58:54 +0900

n 번째 원소부터

문제

정수 리스트 num_list와 정수 n이 주어질 때, n 번째 원소부터 마지막 원소까지의 모든 원소를 담은 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항
- 2 ≤ num_list의 길이 ≤ 30
- 1 ≤ num_list의 원소 ≤ 9
- 1 ≤ n ≤ num_list의 길이

소스 코드

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

let num_list = [];
let n = 0;
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    num_list = line.split(' ').map(Number);
  } else {
    n = Number(line)
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(input, queries);
  console.log(answer);
});

const solution = (num_list, n) => {
  return num_list.slice(n - 1);
};

순서 바꾸기

문제

정수 리스트 num_list와 정수 n이 주어질 때, num_list를 n 번째 원소 이후의 원소들과 n 번째까지의 원소들로 나눠 n 번째 원소 이후의 원소들을 n 번째까지의 원소들 앞에 붙인 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항
- 2 ≤ num_list의 길이 ≤ 30
- 1 ≤ num_list의 원소 ≤ 9
- 1 ≤ n ≤ num_list의 길이

소스 코드

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

let num_list = [];
let n = 0;
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    num_list = line.split(' ').map(Number);
  } else {
    n = Number(line)
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(input, queries);
  console.log(answer);
});

const solution = (num_list, n) => {
  let a = num_list.slice(0, n);
  let b = num_list.slice(n);
  return [...b, ...a];
};

왼쪽 오른쪽

문제

문자열 리스트 str_list에는 "u", "d", "l", "r" 네 개의 문자열이 여러 개 저장되어 있습니다. str_list에서 "l"과 "r" 중 먼저 나오는 문자열이 "l"이라면 해당 문자열을 기준으로 왼쪽에 있는 문자열들을 순서대로 담은 리스트를, 먼저 나오는 문자열이 "r"이라면 해당 문자열을 기준으로 오른쪽에 있는 문자열들을 순서대로 담은 리스트를 return하도록 solution 함수를 완성해주세요. "l"이나 "r"이 없다면 빈 리스트를 return합니다.

제한사항
- 1 ≤ str_list의 길이 ≤ 20
- str_list는 "u", "d", "l", "r" 네 개의 문자열로 이루어져 있습니다.

소스 코드

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

let num_list = [];

rl.on('line', (line) => {
  num_list = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(input, queries);
  console.log(answer);
});

const solution = str_list => {
  for (let i = 0; i < str_list.length; i++) {
    if (str_list[i] === 'l') {
      return str_list.slice(0, i);
    } else if (str_list[i] === 'r' && i < str_list.length) {
      return str_list.slice(i + 1);
    }
  }
  return [];
};

n 번째 원소까지

문제

정수 리스트 num_list와 정수 n이 주어질 때, num_list의 첫 번째 원소부터 n 번째 원소까지의 모든 원소를 담은 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항
- 2 ≤ num_list의 길이 ≤ 30
- 1 ≤ num_list의 원소 ≤ 9
- 1 ≤ n ≤ num_list의 길이 ___

소스 코드

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

let num_list = [];
let n = 0;
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    num_list = line.split(' ').map(Number);
  } else {
    n = Number(line)
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(input, queries);
  console.log(answer);
});

const solution = (num_list, n) => {
  return num_list.slice(0, n);
};

n개 간격의 원소들

문제

정수 리스트 num_list와 정수 n이 주어질 때, num_list의 첫 번째 원소부터 마지막 원소까지 n개 간격으로 저장되어있는 원소들을 차례로 담은 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항
- 5 ≤ num_list의 길이 ≤ 20
- 1 ≤ num_list의 원소 ≤ 9
- 1 ≤ n ≤ 4

소스 코드

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

let num_list = [];
let n = 0;
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    num_list = line.split(' ').map(Number);
  } else {
    n = Number(line)
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(input, queries);
  console.log(answer);
});

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

  return answer
};

프로그래머스/Javascript : 기초 문제 12일차

Mon, 18 Mar 2024 01:32:51 +0900

리스트 자르기

문제

정수 n과 정수 3개가 담긴 리스트 slicer 그리고 정수 여러 개가 담긴 리스트 num_list가 주어집니다. slicer에 담긴 정수를 차례대로 a, b, c라고 할 때, n에 따라 다음과 같이 num_list를 슬라이싱 하려고 합니다.

n = 1 : num_list의 0번 인덱스부터 b번 인덱스까지 n = 2 : num_list의 a번 인덱스부터 마지막 인덱스까지 n = 3 : num_list의 a번 인덱스부터 b번 인덱스까지 n = 4 : num_list의 a번 인덱스부터 b번 인덱스까지 c 간격으로 올바르게 슬라이싱한 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항
- n 은 1, 2, 3, 4 중 하나입니다.
- slicer의 길이 = 3
- slicer에 담긴 정수를 차례대로 a, b, c라고 할 때
  - 0 ≤ a ≤ b ≤ num_list의 길이 - 1
  - 1 ≤ c ≤ 3
- 5 ≤ num_list의 길이 ≤ 30
- 0 ≤ num_list의 원소 ≤ 100

소스 코드

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

let n = '';
let slicer = [];
let num_list = [];
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    n = Number(line);
  } else if (count === 1){
    slicer = line.split(' ').map(Number)
  } else {
    num_list = line.split(' ').map(Number);
  }
  count++;
  if (count > 2) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(n, slicer, num_list);
  console.log(answer);
});

const solution = (n, slicer, num_list) => {
  switch (n) {
    case 1:
      return num_list.slice(0, slicer[1]+1);
    case 2:
      return num_list.slice(slicer[0]);
    case 3:
      return num_list.slice(slicer[0], slicer[1]+1);
    case 4:
      const list = num_list.slice(slicer[0], slicer[1]+1);
      return list.filter((_, index) => index % slicer[2] === 0)
  }
};

첫 번째로 나오는 음수

문제

정수 리스트 num_list가 주어질 때, 첫 번째로 나오는 음수의 인덱스를 return하도록 solution 함수를 완성해주세요. 음수가 없다면 -1을 return합니다.

제한사항
- 5 ≤ num_list의 길이 ≤ 100
- 10 ≤ num_list의 원소 ≤ 100

소스 코드

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

let input = '';

rl.on('line', (line) => {
  input = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(input);
  console.log(answer);
});

const solution = (num_list) => {
  let count = 0;
  while (true) {
    if (num_list[count] < 0) {
      return count;
    }
    if (count > num_list.length) {
      return -1;
    }
    count++;
  }
};

배열 만들기 3

문제

정수 배열 arr와 2개의 구간이 담긴 배열 intervals가 주어집니다.

intervals는 항상 [[a1, b1], [a2, b2]]의 꼴로 주어지며 각 구간은 닫힌 구간입니다. 닫힌 구간은 양 끝값과 그 사이의 값을 모두 포함하는 구간을 의미합니다.

이때 배열 arr의 첫 번째 구간에 해당하는 배열과 두 번째 구간에 해당하는 배열을 앞뒤로 붙여 새로운 배열을 만들어 return 하는 solution 함수를 완성해 주세요.

소스 코드

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

let arr = [];
let intervals = [];
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    arr = line.split(' ').map(Number);
  } else {
    intervals = line.split(' ').map(
      item => item.split(','),
    );
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(arr, intervals);
  console.log(answer);
});

const solution = (arr, intervals) => {
  let answer = [];
  intervals.map(interval => {
    answer.push(...arr.slice(interval[0], interval[1] + 1));
  });

  return answer;
};

배열 만들기 3

문제

정수 배열 arr와 2개의 구간이 담긴 배열 intervals가 주어집니다.

제한사항
- 1 ≤ arr의 길이 ≤ 100,000
  - 1 ≤ arr의 원소 < 100
- 1 ≤ a1 ≤ b1 < arr의 길이
- 1 ≤ a2 ≤ b2 < arr의 길이

소스 코드

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

let arr = [];
let intervals = [];
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    arr = line.split(' ').map(Number);
  } else {
    intervals = line.split(' ').map(
      item => item.split(','),
    );
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(arr, intervals);
  console.log(answer);
});

const solution = (arr, intervals) => {
  let answer = [];
  intervals.map(interval => {
    answer.push(...arr.slice(interval[0], interval[1] + 1));
  });

  return answer;
};

2의 영역

문제

정수 배열 arr가 주어집니다. 배열 안의 2가 모두 포함된 가장 작은 연속된 부분 배열을 return 하는 solution 함수를 완성해 주세요.

단, arr에 2가 없는 경우 [-1]을 return 합니다.

제한사항
- 1 ≤ arr의 길이 ≤ 100,000
  - 1 ≤ arr의 원소 ≤ 10

소스 코드

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

let input = '';

rl.on('line', (line) => {
  input = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(input);
  console.log(answer);
});

const solution = arr => {
  const start = arr.indexOf(2);
  if (start !== -1) {
    const end = (arr.reverse()).indexOf(2);

    return arr.reverse().slice(start, arr.length - end);
  }

  return [-1];
};

배열 조각하기

문제

정수 배열 arr와 query가 주어집니다.

query를 순회하면서 다음 작업을 반복합니다.

짝수 인덱스에서는 arr에서 query[i]번 인덱스를 제외하고 배열의 query[i]번 인덱스 뒷부분을 잘라서 버립니다. 홀수 인덱스에서는 arr에서 query[i]번 인덱스는 제외하고 배열의 query[i]번 인덱스 앞부분을 잘라서 버립니다. 위 작업을 마친 후 남은 arr의 부분 배열을 return 하는 solution 함수를 완성해 주세요.

제한사항
- 1 ≤ arr의 길이 ≤ 100,000
  - 1 ≤ arr의 원소 < 100
- 1 ≤ a1 ≤ b1 < arr의 길이
- 1 ≤ a2 ≤ b2 < arr의 길이

소스 코드

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

let arr = [];
let query = [];
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    arr = line.split(' ').map(Number);
  } else {
    query = line.split(' ').map(Number);
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(arr, query);
  console.log(answer);
});

const 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]);
    }
  }

  return answer;
};

프로그래머스/Javascript : 기초 문제 11일차

Thu, 14 Mar 2024 01:52:59 +0900

문자 개수 세기

문제

알파벳 대소문자로만 이루어진 문자열 my_string이 주어질 때, my_string에서 'A'의 개수, my_string에서 'B'의 개수,..., my_string에서 'Z'의 개수, my_string에서 'a'의 개수, my_string에서 'b'의 개수,..., my_string에서 'z'의 개수를 순서대로 담은 길이 52의 정수 배열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ my_string의 길이 ≤ 1,000

소스 코드

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

let input = '';

rl.on('line', (line) => {
  input = line;
  rl.close();
}).on('close', () => {
  const answer = solution(input);
  console.log(answer);
});

const solution = my_string => {
  let alphabetArray = Array.from({ length: 52 }, () => 0);
  const startCapitals = 'A'.codePointAt();
  const endCapitals = 'Z'.codePointAt();
  const startSmalls = 'a'.codePointAt();
  const endSmalls = 'z'.codePointAt();

  const array = my_string.split('');
  array.map(item => {
    if (item.codePointAt() >= startCapitals && item.codePointAt() <= endCapitals) {
      alphabetArray[item.codePointAt() - startCapitals] += 1;
    } else if (item.codePointAt() >= startSmalls && item.codePointAt() <= endSmalls) {
      alphabetArray[item.codePointAt() - startSmalls + 26] += 1;
    }
  });

  return alphabetArray;
};

배열 만들기 1

문제

정수 n과 k가 주어졌을 때, 1 이상 n이하의 정수 중에서 k의 배수를 오름차순으로 저장한 배열을 return 하는 solution 함수를 완성해 주세요.

제한사항
- 1 ≤ n ≤ 1,000,000
- 1 ≤ k ≤ min(1,000, n)

소스 코드

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

let input = '';

rl.on('line', (line) => {
  input = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(input[0], input[1]);
  console.log(answer);
});

const solution = (n, k) => {
  let array = [];
  for (let i = k; i <= n; i += k) {
    array.push(i);
  }

  return array;
};

글자 지우기

문제

문자열 my_string과 정수 배열 indices가 주어질 때, my_string에서 indices의 원소에 해당하는 인덱스의 글자를 지우고 이어 붙인 문자열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ indices의 길이 < my_string의 길이 ≤ 100
- my_string은 영소문자로만 이루어져 있습니다
- 0 ≤ indices의 원소 < my_string의 길이
- indices의 원소는 모두 서로 다릅니다.

소스 코드

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

let my_string = '';
let n = 0;
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    my_string = line;
  } else {
    n = line.split(' ').map(Number);
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(my_string, n);
  console.log(answer);
});

const solution = (my_string, indices) => {
  let answer = [...my_string];
  let sortedIndices = indices.sort((a, b) => a - b);
  console.log(sortedIndices);
  for (let index in sortedIndices) {
    answer.splice(sortedIndices[index] - index, 1);
  }

  return answer.join('');
};

카운트 다운

문제

정수 start_num와 end_num가 주어질 때, start_num에서 end_num까지 1씩 감소하는 수들을 차례로 담은 리스트를 return하도록 solution 함수를 완성해주세요.

제한사항
- 0 ≤ end_num ≤ start_num ≤ 50

소스 코드

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

let input = '';

rl.on('line', (line) => {
  input = line.split(' ').map(Number);
  rl.close();
}).on('close', () => {
  const answer = solution(input[0], input[1]);
  console.log(answer);
});

const solution = (start, end_num) => {
  let array = [];
  for (let i = start; i >=end_num; i--) {
    array.push(i);
  }

  return array;
};

가까운 1 찾기

문제

정수 배열 arr가 주어집니다. 이때 arr의 원소는 1 또는 0입니다. 정수 idx가 주어졌을 때, idx보다 크면서 배열의 값이 1인 가장 작은 인덱스를 찾아서 반환하는 solution 함수를 완성해 주세요.

단, 만약 그러한 인덱스가 없다면 -1을 반환합니다.

제한사항
- 3 ≤ arr의 길이 ≤ 100'000
  - arr의 원소는 전부 1 또는 0입니다.

소스 코드

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

let idx = '';
let arr = [];
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    arr = line.split(' ').map(Number);
  } else {
    idx = Number(line);
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(idx, arr);
  console.log(answer);
});

const solution = (arr, idx) => {
  return arr.indexOf(1, idx);
};

프로그래머스/Javascript : 기초 문제 10일차

Tue, 12 Mar 2024 00:47:08 +0900

문자열의 앞의 n글자

문제

문자열 my_string과 정수 n이 매개변수로 주어질 때, my_string의 앞의 n글자로 이루어진 문자열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- my_string은 숫자와 알파벳으로 이루어져 있습니다.
- 1 ≤ my_string의 길이 ≤ 1,000
- 1 ≤ n ≤ my_string의 길이

소스 코드

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

let my_string = '';
let n = 0;
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    my_string = line;
  } else {
    n = line;
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(my_string, Number(n));
  console.log(answer);
});

const solution = (my_string, n) => {
  return my_string.slice(0, n);
};

접두사인지 확인하기

문제

어떤 문자열에 대해서 접두사는 특정 인덱스까지의 문자열을 의미합니다. 예를 들어, "banana"의 모든 접두사는 "b", "ba", "ban", "bana", "banan", "banana"입니다. 문자열 my_string과 is_prefix가 주어질 때, is_prefix가 my_string의 접두사라면 1을, 아니면 0을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ my_string의 길이 ≤ 100
- 1 ≤ is_prefix의 길이 ≤ 100
- my_string과 is_prefix는 영소문자로만 이루어져 있습니다.

소스 코드

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

let my_string = '';
let is_prefix = '';
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    my_string = line;
  } else {
    is_prefix = line;
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(my_string, is_prefix);
  console.log(answer);
});

const solution = (my_string, is_prefix) => {
  const prefix = my_string.slice(0, is_prefix.length);
  return is_prefix.length <= my_string.length && prefix.includes(is_prefix) ? 1 : 0;
};

문자열 뒤집기

문제

문자열 my_string과 정수s, e가 매개변수로 주어질 때, my_string에서 인덱스 s부터 인덱스 e까지를 뒤집은 문자열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- my_string은 숫자와 알파벳으로만 이루어져 있습니다.
- 1 ≤ my_string의 길이 ≤ 1,000
- 0 ≤ s ≤ e < my_string의 길이

소스 코드

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

let my_string = '';
let input = '';
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    my_string = line;
  } else {
    input = line.split(' ').map(Number);
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(my_string, input[0], input[1]);
  console.log(answer);
});

const solution = (my_string, s, e) => {
  const prefix = my_string.slice(0, s);
  const interval = my_string.slice(s, e + 1);
  let reverse = '';
  for (let i = e - s; i >= 0; i--) {
    reverse += interval[i];
  }
  const suffix = my_string.slice(e + 1);

  return prefix + reverse + suffix;
};

세로 읽기

문제

문자열 my_string과 두 정수 m, c가 주어집니다. my_string을 한 줄에 m 글자씩 가로로 적었을 때 왼쪽부터 세로로 c번째 열에 적힌 글자들을 문자열로 return 하는 solution 함수를 작성해 주세요.

제한사항
- my_string은 영소문자로 이루어져 있습니다.
- 1 ≤ m ≤ my_string의 길이 ≤ 1,000
- m은 my_string 길이의 약수로만 주어집니다.
- 1 ≤ c ≤ m

소스 코드

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

let my_string = '';
let input = '';
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    my_string = line;
  } else {
    input = line.split(' ').map(Number);
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(my_string, input[0], input[1]);
  console.log(answer);
});

const solution = (my_string, m, c) => {
  const array = [];
  let answer = '';
  for (let i = 0; i < my_string.length; i += m) {
    array.push(my_string.slice(i, i + m));
  }

  for (let i = 0; i < array.length; i++) {
    answer += (array[i])[c - 1];
  }

  return answer;
};

qr code

문제

두 정수 q, r과 문자열 code가 주어질 때, code의 각 인덱스를 q로 나누었을 때 나머지가 r인 위치의 문자를 앞에서부터 순서대로 이어 붙인 문자열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 0 ≤ r< q ≤ 20
- r < code의 길이 ≤ 1,000
- code는 영소문자로만 이루어져 있습니다.

소스 코드

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

let code = '';
let input = '';
let count = 0;

rl.on('line', (line) => {
  if (count === 0) {
    input = line.split(' ').map(Number);
  } else {
    code = line;
  }
  count++;
  if (count > 1) {
    rl.close();
  }
}).on('close', () => {
  const answer = solution(input[0], input[1], code);
  console.log(answer);
});

const solution = (q, r, code) => {
  let answer = '';
  for (let i = r; i < code.length; i += q) {
    answer += code[i];
  }

  return answer;
};

프로그래머스/Javascript : 기초 문제 9일차

Sun, 03 Mar 2024 19:43:10 +0900

배열 만들기 5

문제

문자열 배열 intStrs와 정수 k, s, l가 주어집니다. intStrs의 원소는 숫자로 이루어져 있습니다.

배열 intStrs의 각 원소마다 s번 인덱스에서 시작하는 길이 l짜리 부분 문자열을 잘라내 정수로 변환합니다. 이때 변환한 정수값이 k보다 큰 값들을 담은 배열을 return 하는 solution 함수를 완성해 주세요.

제한사항
- 0 ≤ s < 100
- 1 ≤ l ≤ 8
- 10l - 1 ≤ k < 10l
- 1 ≤ intStrs의 길이 ≤ 10,000
  - s + l ≤ intStrs의 원소의 길이 ≤ 120

소스 코드

const solution = (intStrs, k, s, l) => {
  let answer = [];
  intStrs.map(item => {
    const array = item.split('');
    let number = '';
    for (let i = s; i < s + l; i++) {
      number += array[i];
    }
    console.log(number);
    if (Number(number) > k) {
      answer.push(number);
    }
  });

  return answer.map(Number);
};

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

문제

길이가 같은 문자열 배열 my_strings와 이차원 정수 배열 parts가 매개변수로 주어집니다. parts[i]는 [s, e] 형태로, my_string[i]의 인덱스 s부터 인덱스 e까지의 부분 문자열을 의미합니다. 각 my_strings의 원소의 parts에 해당하는 부분 문자열을 순서대로 이어 붙인 문자열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ my_strings의 길이 = parts의 길이 ≤ 100
- 1 ≤ my_strings의 원소의 길이 ≤ 100
- parts[i]를 [s, e]라 할 때, 다음을 만족합니다.
- 0 ≤ s ≤ e < my_strings[i]의 길이

소스 코드

const solution = (my_strings, parts) => {
  let answer = [];
  for (let i = 0; i < parts.length; i++) {
    answer.push(my_strings[i].slice(parts[i][0], parts[i][1]+1));
  }
  return answer.join('');
};

문자열의 뒤의 n글자

문제

문자열 my_string과 정수 n이 매개변수로 주어질 때, my_string의 뒤의 n글자로 이루어진 문자열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- my_string은 숫자와 알파벳으로 이루어져 있습니다.
- 1 ≤ my_string의 길이 ≤ 1,000
- 1 ≤ n ≤ my_string의 길이

소스 코드

const solution = (my_string, n) => {
  return my_string.slice(my_string.length - n);
};

접미사 배열

문제

어떤 문자열에 대해서 접미사는 특정 인덱스부터 시작하는 문자열을 의미합니다. 예를 들어, "banana"의 모든 접미사는 "banana", "anana", "nana", "ana", "na", "a"입니다. 문자열 my_string이 매개변수로 주어질 때, my_string의 모든 접미사를 사전순으로 정렬한 문자열 배열을 return 하는 solution 함수를 작성해 주세요.

제한사항
- my_string은 알파벳 소문자로만 이루어져 있습니다.
- 1 ≤ my_string의 길이 ≤ 100

소스 코드

const solution = (my_string) => {
  let answer= []
  for (let i = 1; i <= my_string.length; i++) {
    answer.push(my_string.slice(my_string.length - i));
  }

  return answer.sort();
};

접미사인지 확인하기

문제

어떤 문자열에 대해서 접미사는 특정 인덱스부터 시작하는 문자열을 의미합니다. 예를 들어, "banana"의 모든 접미사는 "banana", "anana", "nana", "ana", "na", "a"입니다. 문자열 my_string과 is_suffix가 주어질 때, is_suffix가 my_string의 접미사라면 1을, 아니면 0을 return 하는 solution 함수를 작성해 주세요.

제한사항
- 1 ≤ my_string의 길이 ≤ 100
- 1 ≤ is_suffix의 길이 ≤ 100
- my_string과 is_suffix는 영소문자로만 이루어져 있습니다.

소스 코드

const solution = (my_string, is_suffix) => {
  const suffix = my_string.slice(my_string.length - is_suffix.length);
  return suffix.includes(is_suffix) ? 1 : 0;
};

is_suffix 길이 만큼 뒤에서 slice해준 다음 문자열 포함 여부를 확인하면 된다.

laetipark (박동훈)

구글 SEO(검색엔진 최적화) 개념 정리

SEO란?

SEO를 하는 이유

SEO 작업 3 요소

On-Server(On-Page) SEO

웹 사이트 형식, 주소 체계

모바일 호환 및 페이지 속도 측정 : PageSpeed Insights

웹표준 점검 : https://validator.w3.org

깨진 링크 점검 : https://validator.w3.org/checklink

XML 사이트맵 제작

사이트 파악 및 오류 등 개선 : https://search.google.com/search-console/about

On-Page SEO

제목(Title)과 메타 설명(Meta Description)

본문 Text 최적화 작업

사이트 분석

Off-Page SEO

참고

Javascript/Algorithm : 전위/중위/후위 표기법

개요

중위 표기법

전위 표기법

후위 표기법

중위 표기법을 후위 표기법으로 변환 코드

후위 표기법 계산 코드

프로그래머스/Javascript : 기초 문제 22일차

문제

소스 코드

문제

소스 코드

문제

소스 코드

문제

소스 코드

문제

소스 코드

Javascript : 이벤트와 이벤트 위임

이벤트

이벤트 위임

이벤트 관련 함수

Typescript : 타입스크립트 언어의 특징과 장단점

Typescript

타입스크립트 장단점

관련 포스트

참고 자료

Javascript : 프로토타입과 this, call, apply, bind

프로토타입

this

call, apply, bind

Javascript : var, let, const, 스코프

var

let, const

스코프

프로그래머스/Javascript : 기초 문제 21일차

문제

소스 코드

문제

소스 코드

문제

소스 코드

문제

소스 코드

문제

소스 코드

프로그래머스/Javascript : 기초 문제 20일차

문제

소스 코드

문제

소스 코드

문제

소스 코드

문제

소스 코드

문제

소스 코드

프로그래머스/Javascript : 기초 문제 19일차

문제

소스 코드

문제

소스 코드