반응형

구조 분해 할당

객체와 배열은 자바스크립트에서 가장 많이 쓰이는 자료 구조입니다.

코드 작성을 하다 보면 함수에 객체나 배열을 전달하는 경우나, 객체나 배열에 저장된 데이터 전체가 아닌 일부만 필요한 경우도 생깁니다.

이럴 때 객체나 배열을 변수로 분해할 수 있게 해주는 문법이 구조 분해 할당( Destructuring Assignment )입니다.

이 외에도 함수의 매개변수가 많거나 매개변수 기본 값이 필요한 경우 등에서 구조 분해( Destructuring )는 진가를 발휘합니다.

 

배열 분해하기

이렇게 사용하면 인덱스를 이용해서 배열에 접근하지 않고 변수로 사용할 수 있게 됩니다.

const arr = ["Hello", "World"];

// 구조 분해 할당을 이용해서 각각에 Hello와 World를 할당합니다.
const [first, second] = arr;

console.log(first); // Hello
console.log(second); // World

 

split() 메서드와 함께 사용하기

const str = "Hello World";

const [first, second] = str.split(" ");

console.log(first); // Hello
console.log(second); // World

 

분해( Destructuring )의 의미

구조 분해 할당이란 명칭은 어떤 것을 복사한 이후 변수로 분해 해준다는 의미 때문에 붙었습니다. 이 과정에서 수정 혹은 파괴되지 않습니다.

 

쉼표를 사용해서 요소 버리기

쉼표를 사용하면 필요하지 않은 배열의 요소를 버릴 수 있습니다.

const arr = ["안녕", "하세요", "저는", "Shiro", "21입니다."];

const [first, , second, third] = arr;
console.log(first); // 안녕
console.log(second); // 저는
console.log(third); // Shiro

 

할당 연산자 우측엔 모든 iterable( 이터러블 )이 올 수 있습니다.

배열뿐 아니라 모든 iterable( 반복 가능한 객체 )에 구조 분해 할당을 적용할 수 있습니다.

const [a, b, c] = "abc";
const [one, two, three] = new Set([1, 2, 3]);
console.log(a); // a
console.log(b); // b
console.log(c); // c

console.log(one); // 1
console.log(two); // 2
console.log(three); // 3

 

할당 연산자 좌측에는 무엇이든 올 수 있습니다.

할당 연산자 좌측에는 할당할 수 있는( Assignables )것이라면 어떤 것이든 올 수 있습니다.

const str = "Jun Hyeok"
const user = {};
[user.Firstname, user.secondName] = str.split(" ");

console.log(user.Firstname); // Jun
console.log(user.secondName); // Hyeok

 

.entries() 메서드로 반복하기

entries() 메서드와 구조 분해를 조합하면 객체의 키와 값을 순회해서 변수로 분해 할당할 수 있습니다.

const user = {
  name: "Shiro",
  age: 31
};

for (let [key, value] of Object.entries(user)) {
  console.log(`key: ${key}, value: ${value}`); 
  /*
    key: name, value: Shiro
    key: age, value: 31
  */
}

 

변수 교환 트릭

두 변수에 저장된 값을 교환할 때 구조 분해 할당을 사용할 수 있습니다.

let Guest = "Shiro";
let Admin = "Jun";

[Guest, Admin] = [Admin, Guest];

console.log(`Guest: ${Guest}, Admin: ${Admin}`); // Guest: Jun, Admin: Shiro

 

이 방식을 사용하면 2개 이상의 변수에 담긴 값도 교환할 수 있습니다.

 

스프레드 연산자로 나머지 요소 가져오기

배열 앞쪽에 위치한 값 몇 개만 필요하고 그 이후 이어지는 나머지 값들은 한데 모아 저장하고 싶을 때 스프레드 연산자인 ...을 붙인 매개변수를 추가하면 나머지 요소를 가져올 수 있습니다.

let [first, second, ...third] = ["A", "B", "C", "D", "E", "F", "G", "H"];

console.log(first); // A
console.log(second); // B
console.log(third); // ['C', 'D', 'E', 'F', 'G', 'H']
console.log(third.length); // 6

...뒤에는 다른 이름이 와도 괜찮지만, 변수 앞에 ...과 가장 마지막에 위치해야 한다는 점은 지켜주어야 합니다.

 

기본 값

할당하고자 하는 변수의 개수가 분해하고자 하는 배열의 길이보다 크더라도 에러가 발생하지 않습니다.

let [first, second] = [];

console.log(first); // undefined
console.log(second); // undefined

할당할 값이 없으면 undefined로 취급됩니다.

 

객체 분해하기

구조 분해 할당으로 객체도 분해할 수 있습니다.

let { cnt1, cnt2 } = { cnt1: "", cnt2: "" }
let options = {
  title: "New World",
  subTitle: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
  width: 1000,
  height: 1000
};

let {title, subTitle, width, height} = options;

console.log(title, subTitle, width, height); // New World ABCDEFGHIJKLMNOPQRSTUVWXYZ 1000 1000

순서는 중요하지 않습니다.

 

할당 연산자 좌측에 좀 더 복잡한 패턴이 올 수 있습니다. 분해하려는 객체의 프로퍼티와 변수의 연결을 원하는 대로 조정할 수 있습니다.

let options = {
  title: "New World",
  subTitle: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
  width: 1000,
  height: 1000
};

let {title: tt, subTitle, width: w, height: h} = options;

console.log(tt, w, h); // New World 1000 1000

 

프로퍼티가 없는 경우를 대비해서 =을 사용해서 기본 값을 설정하는 것도 가능합니다.

let options = {
  title: "New World",
  subTitle: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
  width: 1000,
  height: 1000
};

let {title, abc = 100} = options;

console.log(title, abc); // New World 100

 

나머지 패턴 ...

나머지 패턴( Rest Pattern )을 사용하면 배열에서 했던 것처럼 나머지 프로퍼티를 어딘가에 할당하는 것이 가능합니다.

let options = {
  title: "New World",
  subTitle: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
  width: 1000,
  height: 1000
};

let {subTitle, ...rest} = options;

console.log(subTitle, rest.title); // ABCDEFGHIJKLMNOPQRSTUVWXYZ New World

 

중첩 구조 분해

객체나 배열이 다른 객체나 배열을 포함하는 경우, 좀 더 복잡한 패턴을 사용하면 중첩 배열이나  객체의 정보를 추출할 수 있습니다. 이를 중첩 구조 분해( Nested Destructuring )라고 합니다.

let options = {
  size: {
    width: 1000,
    height: 1000
  },
  items: ["Hello", "World"],
  bool: true
};

let { size: { width, height }, items: [ item1, item2 ], title = "Main" } = options;

console.log(width); // 1000
console.log(height); // 1000
console.log(item1); // Hello
console.log(item2); // World
console.log(title); // Main

title은 프로퍼티가 없으므로 기본 값을 넣어주었습니다.

반응형
반응형

푸드 파이트 대회

 

문제 설명

수웅이는 매달 주어진 음식을 빨리 먹는 푸드 파이트 대회를 개최합니다. 이 대회에서 선수들은 1대 1로 대결하며, 매 대결마다 음식의 종류와 양이 바뀝니다. 대결은 준비된 음식들을 일렬로 배치한 뒤, 한 선수는 제일 왼쪽에 있는 음식부터 오른쪽으로, 다른 선수는 제일 오른쪽에 있는 음식부터 왼쪽으로 순서대로 먹는 방식으로 진행됩니다. 중앙에는 물을 배치하고, 물을 먼저 먹는 선수가 승리하게 됩니다.

이때, 대회의 공정성을 위해 두 선수가 먹는 음식의 종류와 양이 같아야 하며, 음식을 먹는 순서도 같아야 합니다. 또한, 이번 대회부터는 칼로리가 낮은 음식을 먼저 먹을 수 있게 배치하여 선수들이 음식을 더 잘 먹을 수 있게 하려고 합니다. 이번 대회를 위해 수웅이는 음식을 주문했는데, 대회의 조건을 고려하지 않고 음식을 주문하여 몇 개의 음식은 대회에 사용하지 못하게 되었습니다.

예를 들어, 3가지의 음식이 준비되어 있으며, 칼로리가 적은 순서대로 1번 음식을 3개, 2번 음식을 4개, 3번 음식을 6개 준비했으며, 물을 편의상 0번 음식이라고 칭한다면, 두 선수는 1번 음식 1개, 2번 음식 2개, 3번 음식 3개씩을 먹게 되므로 음식의 배치는 "1223330333221"이 됩니다. 따라서 1번 음식 1개는 대회에 사용하지 못합니다.

수웅이가 준비한 음식의 양을 칼로리가 적은 순서대로 나타내는 정수 배열 food가 주어졌을 때, 대회를 위한 음식의 배치를 나타내는 문자열을 return 하는 solution 함수를 완성해 주세요.


제한사항
  • 2 ≤ food의 길이 ≤ 9
  • 1 ≤ food의 각 원소 ≤ 1,000
  • food에는 칼로리가 적은 순서대로 음식의 양이 담겨 있습니다.
  • food[i]는 i번 음식의 수입니다.
  • food[0]은 수웅이가 준비한 물의 양이며, 항상 1입니다.
  • 정답의 길이가 3 이상인 경우만 입력으로 주어집니다.

입출력 예foodresult
[1, 3, 4, 6] "1223330333221"
[1, 7, 1, 2] "111303111"

입출력 예 설명

입출력 예 #1

  • 문제 예시와 같습니다.

입출력 예 #1

  • 두 선수는 1번 음식 3개, 3번 음식 1개를 먹게 되므로 음식의 배치는 "111303111"입니다.

 

function solution(food) {
    var answer = '';
    let arr = [];
    
    for (let i = 1; i < food.length; i++) {
        for (let j = 0; j < Math.floor(food[i] / 2); j++) {
            arr.push(i)
        }
    }
    
    answer = [...arr, 0, ...arr.reverse()].join("")
    return answer;
}

console.log(solution([1, 3, 4, 6])); // 1223330333221
console.log(solution([1, 7, 1, 2])); // 111303111

for문을 통해 1번 푸드부터 3번 푸드까지 for문을 돌려주고, 내부에서 Math.floor() 함수를 통해서 food[i]를 반으로 나눠준 것에 내림을 한 다음 arr에 1 ~ 3번 음식을 반씩만 넣어줍니다. 이후 for문이 종료 후에 answer변수에 for문에서 뽑아낸 반을 넣어주고, 중간에 0을 넣어준 다음 arr.reverse() 메서드로 나머지 반을 반대로 넣어주고 join() 메서드를 통해서 하나의 문자열로 만들어서 반환해 주었습니다.

[..arr, 0, ...arr.reverse()]부분은 전개 구문인 Spread Operator( 스프레드 연산자 )를 사용했습니다.

 

처음에 물을 0번이라고 칭한 것을 못 보고 계속 문제만 읽었던듯합니다..ㅠ 

 

  • Math.floor() 함수: 주어진 숫자와 같거나 작은 정수 중에서 가장 큰 수를 반환합니다.
  • join() 메서드: 배열의 모든 요소를 연결해 하나의 문자열로 만들어줍니다.
  • reverse() 메서드: 배열의 순서를 반전합니다. 첫 번째 요소는 마지막 요소가 되며, 마지막 요소는 첫 번째 요소가 됩니다.

 

소요시간 1시간 10분

 

다른 사람의 풀이

function solution(food) {
    let res = '';
    for (let i = 1; i < food.length; i++) {
        res += String(i).repeat(Math.floor(food[i]/2));
    }

    return res + '0' + [...res].reverse().join('');
}

repeat() 메서드를 사용해서 결과를 내신 분들이 많은듯하여 repeat() 메서드도 한번 훑어봐야겠습니다..!!

반응형
반응형

음양 더하기

 

문제 설명

어떤 정수들이 있습니다. 이 정수들의 절댓값을 차례대로 담은 정수 배열 absolutes와 이 정수들의 부호를 차례대로 담은 불리언 배열 signs가 매개변수로 주어집니다. 실제 정수들의 합을 구하여 return 하도록 solution 함수를 완성해주세요.


제한사항
  • absolutes의 길이는 1 이상 1,000 이하입니다.
    • absolutes의 모든 수는 각각 1 이상 1,000 이하입니다.
  • signs의 길이는 absolutes의 길이와 같습니다.
    • signs[i] 가 참이면 absolutes[i] 의 실제 정수가 양수임을, 그렇지 않으면 음수임을 의미합니다.

입출력 예absolutessignsresult
[4,7,12] [true,false,true] 9
[1,2,3] [false,false,true] 0

입출력 예 설명

입출력 예 #1

  • signs가 [true,false,true] 이므로, 실제 수들의 값은 각각 4, -7, 12입니다.
  • 따라서 세 수의 합인 9를 return 해야 합니다.

입출력 예 #2

  • signs가 [false,false,true] 이므로, 실제 수들의 값은 각각 -1, -2, 3입니다.
  • 따라서 세 수의 합인 0을 return 해야 합니다.

 

function solution(absolutes, signs) {
    var answer = 123456789;
    
    for (let i = 0; i < absolutes.length; i++) {
        if (signs[i] === false) absolutes[i] = absolutes[i] * -1;
    }
    
    const result = absolutes.reduce((a, b) => a + b);
    
    answer = result;
    
    return answer;
}

console.log(solution([4,7,12], [true,false,true])); // 9
console.log(solution([1,2,3], [false,false,true])); // 0

absolues와 signs를 차례대로 담은 배열이기 때문에 둘중에 하나를 for문으로 돌려서 signs값이 false인 경우 -1을 곱해줍니다.

이후, reduce() 메서드를 사용해서 하나의 결과값으로 반환해줍니다.

 

  • reducer()메서드: 배열의 각 요소에 대해 주어진 리듀서 ( reducer )함수를 실행하고, 하나의 결과 값을 반환합니다.

 

소요시간 5분

 

다른 사람의 풀이

function solution(absolutes, signs) {

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

acc[누산기] + ( val[현재 값] * ( signs[i][삼항 연산자] ? 1[true] : -1[false] ), 0[초기 값]);

짧다..ㅠ

반응형
반응형

indexOf() 메서드

indexOf() 메서드는 배열에서 지정된 요소를 찾을 수 있는 첫 번째 인덱스를 반환하고 존재하지 않으면 -1을 반환합니다.

 

구문

arr.indexOf(searchElement[, fromIndex]);

 

매개변수

  • searchElement: 배열에서 찾을 요소입니다.
  • fromIndex: 검색을 시작할 색인입니다. 인덱스가 배열의 길이보다 크거나 같은 경우 -1이 반환되므로, 배열이 검색되지 않습니다. 제공된 색인 값이 음수라면 배열 끝에서부터 오프셋 값으로 사용됩니다.
    :: 제공된 색인이 음수라면 배열은 여전히 앞에서 뒤로 검색됩니다. 계산된 인덱스가 0보다 작으면 전체 배열이 검색됩니다. ( 기본값: 0 [전체 배열 검색] )

 

반환 값

배열 내 요소의 최초 인덱스입니다. 없으면 -1을 반환합니다.

 

예제

 

첫 번째 인덱스 반환 확인하기

const arr = ["안녕", "하세요", "저는", "Shiro21입니다.", "안녕", "저는"];

console.log(arr.indexOf("안녕")); // 0
console.log(arr.indexOf("저는")); // 2
console.log(arr.indexOf("안녕하")); // -1

console.log(arr.indexOf("안녕", "저는")); // 0
console.log(arr.indexOf("안녕", "저는여")); // 0
console.log(arr.indexOf("안녕하", "저는")); // -1

 

요소의 모든 항목 찾기

// 같은 내용입니다.

const arr = ["안녕", "하세요", "저는", "Shiro21입니다.", "안녕", "저는"];
const newArr = [];

for (let i = 0; i < arr.length; i++) {
  if (arr[i].indexOf("안녕") > -1) newArr.push(i)
}

console.log(newArr); // [0, 4]


// -------------------------------------------------------------------- //

const arr = ["안녕", "하세요", "저는", "Shiro21입니다.", "안녕", "저는"];
const newArr = [];
let idx = arr.indexOf("안녕");

while (idx !== -1) {
  newArr.push(idx);
  idx = arr.indexOf("안녕", idx + 1);
}

console.log(newArr); // [0, 4]

while문을 사용할 때는 무한루프에 빠지지 않게 조심해야 합니다.

반응형
반응형

인덱스 바꾸기

 

문제 설명

문자열 my_string과 정수 num1, num2가 매개변수로 주어질 때, my_string에서 인덱스 num1과 인덱스 num2에 해당하는 문자를 바꾼 문자열을 return 하도록 solution 함수를 완성해보세요.


제한사항
  • 1 < my_string의 길이 < 100
  • 0 ≤ num1, num2 < my_string의 길이
  • my_string은 소문자로 이루어져 있습니다.
  • num1  num2

입출력 예my_stringnum1num2result
"hello" 1 2 "hlelo"
"I love you" 3 6 "I l veoyou"

입출력 예 설명

입출력 예 #1

  • "hello"의 1번째 인덱스인 "e"와 2번째 인덱스인 "l"을 바꾸면 "hlelo"입니다.

입출력 예 #2

  • "I love you"의 3번째 인덱스 "o"와 " "(공백)을 바꾸면 "I l veoyou"입니다.

 

function solution(my_string, num1, num2) {
    var answer = '';
    let arr = [];

    for(let i = 0; i < my_string.length; i++) {
        if (i === num1) arr.push(my_string[num2]);
        else if (i === num2) arr.push(my_string[num1]);
        else arr.push(my_string[i]);
    }

    answer = arr.join("")
    return answer;
}

console.log(solution("hello", 1, 2)); // hlelo
console.log(solution("I love you", 3, 6)); // I l veoyou

 

다른사람의 풀이

function solution(my_string, num1, num2) {
    my_string = my_string.split('');
    [my_string[num1], my_string[num2]] = [my_string[num2], my_string[num1]];
    return my_string.join('');
}

ES6문법인, 구조 분해 문법( Destructuring )을 활용한 내용이라고 합니다. 나중에 제대로 확인해 봐야겠습니다.

반응형
반응형

includes() 메서드

includes() 메서드는 배열이 특정 요소를 포함하고 있는지 확인합니다.

 

구문

arr.includes(valueTofind[, fromIndex]);

 

매개변수

  • valueToFind: 탐색할 요소입니다. ( 문자, 문자열을 비교할 때 includes() 메서드는 대소문자를 구분합니다. )
  • fromIndex: 이 배열에서 searchElement 검색을 시작할 위치입니다. 음의 값일 경우 array.length + fromIndex의 인덱스를 ASC( Ascending )로 검색합니다. 기본값은 0입니다.

 

반환 값

Boolean값입니다.

 

예제

있는지 없는지 확인하기

const arr = [1, 2, 3];

console.log(arr.includes(2)); // true

const pets = ["cat", "dog", "bat"];

console.log(pets.includes("cat")); // true
console.log(pets.includes("c")); // false

 

fromIndex가 배열의 길이와 같거나 길이보다 큰 경우

const arr = ["a", "b", "c"];

console.log(arr.includes("c", 1)); // true
console.log(arr.includes("c", 2)); // true

// C가 대문자입니다.
console.log(arr.includes("C", 2)); // false
// fromIndex가 배열의 길이와 같습니다.
console.log(arr.includes("c", 3)); // false

 

0보다 작은 인덱스의 계산

fromIndex가 음수일 때, 인덱스는 valueToFind를 찾기 시작할 배열의 위치로 사용되기 위해 연산됩니다. 만약 계산된 인덱스가 -1 * array.length보다 작거나 같으면 배열이 검색됩니다.

const arr = ["a", "b", "c"];

console.log(arr.includes("a", -100)); // true
console.log(arr.includes("b", -100)); // true
console.log(arr.includes("c", -100)); // true
console.log(arr.includes("a", -2)); // false
console.log(arr.includes("b", -2)); // true
console.log(arr.includes("c", -2)); // true

arr 배열의 길이는 3입니다. 

3 + ( -100 ) = -97

3 + ( -2 ) = 1

반응형
반응형

from() 메서드

from() 메서드는 유사 배열 객체( array-like object )나 반복 가능한 객체( iterable object )를 얕게 복사해 새로운 Array객체를 만듭니다.

 

구문

Array.from(arrayLike[, mapFn[, thisArg]]);

 

매개변수

  • arrayLike: 배열로 변환하고자 하는 유사 배열 객체나 반복 가능한 객체입니다.
  • mapFn: 배열의 모든 요소에 대해 호출할 맵핑 함수입니다.
  • thisArg: mapFn 실행 시에 this로 사용할 값입니다.

 

반환 값

새로운 Array 인스턴스입니다.

 

예제

// String 배열 만들기
let cnt = "foo";
console.log(Array.from(cnt)); // ['f', 'o', 'o']

let cnt1 = [1, 2, 3, 4, 5];
console.log(Array.from(cnt1, x => x + x)); // [2, 4, 6, 8, 10]

 

Set에서 배열 만들기

const newArr = new Set(["foo", "window"]);

console.log(newArr); // {'foo', 'window'}
console.log(Array.from(newArr)); // ['foo', 'window']

 

Map에서 배열 만들기

const old = new Map([[1, 2], [2, 4], [4, 8]]);

console.log(Array.from(old)); // [[1, 2], [2, 4], [4, 8]]

const mapper = new Map([['1', 'a'], ['2', 'b']]);
console.log(Array.from(mapper.values())); // ['a', 'b']

console.log(Array.from(mapper.keys())); // ['1', '2']

 

반응형
반응형

한 번만 등장한 문자

 

문제 설명

문자열 s가 매개변수로 주어집니다. s에서 한 번만 등장하는 문자를 사전 순으로 정렬한 문자열을 return 하도록 solution 함수를 완성해보세요. 한 번만 등장하는 문자가 없을 경우 빈 문자열을 return 합니다.


제한사항
  • 0 < s의 길이 < 1,000
  • s는 소문자로만 이루어져 있습니다.

입출력 예sresult
"abcabcadc" "d"
"abdc" "abcd"
"hello" "eho"

입출력 예 설명

입출력 예 #1

  • "abcabcadc"에서 하나만 등장하는 문자는 "d"입니다.

입출력 예 #2

  • "abdc"에서 모든 문자가 한 번씩 등장하므로 사전 순으로 정렬한 "abcd"를 return 합니다.

입출력 예 #3

  • "hello"에서 한 번씩 등장한 문자는 "heo"이고 이를 사전 순으로 정렬한 "eho"를 return 합니다.

 

function solution(s) {
    var answer = '';
    let arr = s.split("");
    let duplicateArr = arr.filter((item, index) => arr.indexOf(item) !== index)

    let uniqueArr = arr.filter(item => !duplicateArr.includes(item))

    answer = uniqueArr.sort().join("")
    return answer;
}

console.log(solution("abcabcadc")); // d
console.log(solution("abdc")); // abcd
console.log(solution("hello")); // eho

먼저 duplicateArr에 중복되는 문자들을 모두 넣어줍니다.

다음으로 uniqueArr에 중복되지 않는 문자들을 넣어줍니다.

 

  • split() 메서드: string 객체를 지정한 구분자를 이용하여 여러개의 문자열로 나누어줍니다.
  • filter() 메서드: 주어진 함수의 테스트를 통과하는 모든 요소를 모아 새로운 배열로 반환합니다.
  • indexOf() 메서드: 호출한 string 객체에서 주어진 값과 일치하는 첫 번째 인덱스를 반환합니다. 일치하는 값이 없으면 -1을 반환합니다.
  • includes() 메서드: 배열이 특정 요소를 포함하고 있는지 판별합니다.
  • sort() 메서드: 배열의 요소를 적절한 위치에 정렬한 후 그 배열을 반환합니다. 정렬 순서는 유니코드 코드포인트를 따릅니다.
  • join() 메서드: 배열의 모든 요소를 연결해 하나의 문자열로 만듭니다.

 

다른 사람의 풀이

function solution(s) {
    let res = [];
    for (let c of s) if (s.indexOf(c) === s.lastIndexOf(c)) res.push(c);
    return res.sort().join('');
}

3일전에 lastIndexOf() 메서드를 사용했는데 이렇게 푼다는 생각은 아예 하질 못했습니다. ㄷㄷ

indexOf() 메서드를 사용해서 앞에서부터 일치하는 첫 번째 인덱스를 반환하고, lastIndexOf() 메서드를 사용해서 뒤에서부터 일치하는 마지막 인덱스를 반환합니다.

이렇게 해서 같은 index가 나오면 하나만 있다는게 증명이 됩니다.

반응형
반응형

약수 구하기

 

문제 설명

정수 n이 매개변수로 주어질 때, n의 약수를 오름차순으로 담은 배열을 return하도록 solution 함수를 완성해주세요.


제한사항
  • 1 ≤ n ≤ 10,000

입출력 예nresult
24 [1, 2, 3, 4, 6, 8, 12, 24]
29 [1, 29]

입출력 예 설명

입출력 예 #1

  • 24의 약수를 오름차순으로 담은 배열 [1, 2, 3, 4, 6, 8, 12, 24]를 return합니다.

입출력 예 #2

  • 29의 약수를 오름차순으로 담은 배열 [1, 29]를 return합니다.

 

function solution(n) {
    var answer = [];

    for(let i = 1; i <= n; i++) {
        if (n % i === 0) answer.push(i);
    }

    return answer;
}

console.log(solution(24)); // [1, 2, 3, 4, 6, 8, 12, 24]
console.log(solution(29)); // [1, 29]

for문을 사용해 나머지가 0이 나오는 약수를 만들어줍니다. ( 자신이 포함되어야 하기 때문에 i <= n;으로 만들어줍니다. )

반응형
반응형

명예의 전당 (1)

 

문제 설명

"명예의 전당"이라는 TV 프로그램에서는 매일 1명의 가수가 노래를 부르고, 시청자들의 문자 투표수로 가수에게 점수를 부여합니다. 매일 출연한 가수의 점수가 지금까지 출연 가수들의 점수 중 상위 k번째 이내이면 해당 가수의 점수를 명예의 전당이라는 목록에 올려 기념합니다. 즉 프로그램 시작 이후 초기에 k일까지는 모든 출연 가수의 점수가 명예의 전당에 오르게 됩니다. k일 다음부터는 출연 가수의 점수가 기존의 명예의 전당 목록의 k번째 순위의 가수 점수보다 더 높으면, 출연 가수의 점수가 명예의 전당에 오르게 되고 기존의 k번째 순위의 점수는 명예의 전당에서 내려오게 됩니다.

이 프로그램에서는 매일 "명예의 전당"의 최하위 점수를 발표합니다. 예를 들어, k = 3이고, 7일 동안 진행된 가수의 점수가 [10, 100, 20, 150, 1, 100, 200]이라면, 명예의 전당에서 발표된 점수는 아래의 그림과 같이 [10, 10, 10, 20, 20, 100, 100]입니다.

명예의 전당 목록의 점수의 개수 k, 1일부터 마지막 날까지 출연한 가수들의 점수인 score가 주어졌을 때, 매일 발표된 명예의 전당의 최하위 점수를 return하는 solution 함수를 완성해주세요.

제한사항
  • 3 ≤ k ≤ 100
  • 7 ≤ score의 길이 ≤ 1,000
    • 0 ≤ score[i] ≤ 2,000

입출력 예kscoreresult
3 [10, 100, 20, 150, 1, 100, 200] [10, 10, 10, 20, 20, 100, 100]
4 [0, 300, 40, 300, 20, 70, 150, 50, 500, 1000] [0, 0, 0, 0, 20, 40, 70, 70, 150, 300]

입출력 예 설명

입출력 예 #1

  • 문제의 예시와 같습니다.

입출력 예 #2

  • 아래와 같이, [0, 0, 0, 0, 20, 40, 70, 70, 150, 300]을 return합니다. 

 

function solution(k, score) {
    var answer = [];
    let arr = [];

    for (let i = 0; i < score.length; i++) {

        arr.push(score[i]);

        if (i < k) {
            answer.push(Math.min(...arr));
        } else {
            if (arr.length > k) {
                let cnt1 = Math.min(...arr);

                arr.sort((a, b) => {
                    if (a < b) return -1;
                    // else if (a > b) return 1;
                    // else return 0;
                }).shift()
            }

            answer.push(Math.min(...arr));
        }
    }

    return answer;
}

console.log(solution(3, [10, 100, 20, 150, 1, 100, 200])); // [10, 10, 10, 20, 20, 100, 100]
console.log(solution(4, [0, 300, 40, 300, 20, 70, 150, 50, 500, 1000])); // [0, 0, 0, 0, 20, 40, 70, 70, 150, 300]

먼저 최대 3개의 스코어가 들어가는 arr배열을 만들어서 일차마다 스코어를 하나씩 추가시켜줍니다. ( 4일차부터 가장 낮은 스코어를 탈락 시킨것을 확인하기 위해 )

 

이후, 3일차 까지는 answer에 가장 작은 스코어를 넣어줍니다.

4일차부터 가장 낮은 스코어를 찾은다음 sort() 메서드를 사용해서 낮은순서대로 정렬시킨 후 가장 앞에 있는 스코어 ( 가장 낮은 스코어 )를 빼줍니다. 이후 그중에서 다음으로 낮은 스코어를 추가 시켜줍니다.

:: sort()메서드는 string으로 간주하고 비교를 하기 때문에 compareFunction을 이용해야 합니다.

 

그렇게 answer에 매일 가장 하위 점수를 추가하고 반환해줍니다.

 

  • Math.min 함수: 주어진 숫자들 중 가장 작은 값을 반환합니다.
  • sort() 메서드: 배열의 요소를 적절한 위치에 정렬한 후 그 배열을 반환합니다. 기본 정렬 순서는 문자열의 유니코드 코드 포인트를 따릅니다.
  • shift() 메서드: 배열에서 첫 번째 요소를 제거하고, 제거된 요소를 반환합니다.

 

소요시간 3시간 30분

반응형

+ Recent posts