반응형

join() 메서드

join() 메서드는 배열의 모든 요소를 연결해 하나의 문자열로 만듭니다.

 

구문

arr.join([separator]);

 

매개변수

  • separator: 배열의 각 요소를 구분할 문자열을 지정합니다. 이 구분자는 필요한 경우 문자열로 변환됩니다. 생략하면 배열의 요소들이 쉼표로 구분됩니다. separator가 빈 문자열이면 모든 요소들이 사이에 아무 문자도 없이 연결됩니다.

 

반환 값

배열의 모든 요소들을 연결한 하나의 문자열을 반환합니다. 만약 arr.length가 0이라면 빈 문자열을 반환합니다.

 

예제

여러가지 방법으로 배열 연결하기

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

let a = arr.join();
let b = arr.join(", ");
let c = arr.join(" + ");
let d = arr.join("");

console.log(a); // 안녕,하세요,저는,Shiro21,입니다.
console.log(b); // 안녕, 하세요, 저는, Shiro21, 입니다.
console.log(c); // 안녕 + 하세요 + 저는 + Shiro21 + 입니다.
console.log(d); // 안녕하세요저는Shiro21입니다.

 

반응형
반응형

Array.isArray() 메서드

Array.isArray() 메서드는 인자가 array인지 판별합니다.

 

구문

Array.isArray(obj);

 

매개변수

  • obj: 검사할 객체

 

반환 값

객체가 Array라면 true, Array가 아니라면 false입니다.

 

예제

// TRUE
console.log(Array.isArray([])); // true
console.log(Array.isArray([1])); // true
console.log(Array.isArray(new Array())); // true
console.log(Array.isArray(new Array(3))); // true
console.log(Array.isArray(new Array("a", "b", "c", "d"))); // true
console.log(Array.isArray(Array.prototype)); // true [ Array.prototype은 스스로도 배열입니다. ]

// FALSE
console.log(Array.isArray()); // false
console.log(Array.isArray({})); // false
console.log(Array.isArray(undefined)); // false
console.log(Array.isArray(null)); // false
console.log(Array.isArray(1)); // false
console.log(Array.isArray("A")); // false
console.log(Array.isArray(true)); // false

 

반응형
반응형

구조 분해 할당

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

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

이럴 때 객체나 배열을 변수로 분해할 수 있게 해주는 문법이 구조 분해 할당( 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가 나오면 하나만 있다는게 증명이 됩니다.

반응형

+ Recent posts