사건의 발단

이 문제를 객체로 풀다가 도저히 안되서 검색 => Map자료구조로 푼 글을 봄.

로직은 똑같은데, 시간복잡도에서 차이 발생.
객체와 Map의 차이가 그렇게 심한가...?

=> 이터러블과 아닌것의 차이 인듯 하다...

그렇다면 객체를 이터러블로 만들어보자.

효율성 테스트 빵점

function solution(gems) {
    const gemTypeCount = new Set(gems).size;
  	const obj = {};
    const shortCut = [];

    gems.forEach((gem,i) => {
        delete obj[gem];
        obj[gem] = i;
		const temp = Object.values(obj);
        if(temp.length === gemTypeCount){
            shortCut.push([temp[0] + 1, i + 1 ]);
        }
    })
    
    return shortCut.sort((a,b) => (a[1] - a[0]) - (b[1] - b[0]) || a[0]-b[0])[0];
}

효율성 테스트 반타작

function solution(gems) {
    const gemTypeCount = new Set(gems).size;
    
    const obj = { 
    items:{},
    size:0,
    set(key, value){
        if(this.items[key] === undefined){
            this.size++;
        }
        this.items[key] = value;
    },
        
    delete(key){
        if(this.items[key] !== undefined){
            delete this.items[key];
            this.size --;
        }
    },
    
    [Symbol.iterator]: function () {
        const keys = Object.keys(this.items);
        let index = 0;

        return {
          next: () => {
            if (index < keys.length) {
              const key = keys[index++];
              return { value: this.items[key], done: false };
            } else {
              return { done: true };
            }
          }
        };
    },
    
    values(){
        return this[Symbol.iterator]();
    },
        
    };
    
    let minLength = gems.length;
    
    const shortCut = [];
    
    gems.forEach((gem, i) => {
        obj.delete(gem);
        obj.set(gem,i);
        if(obj.size === gemTypeCount){
            shortCut.push([obj.values().next().value + 1, i+1]);
         }
    })
    
    return shortCut.sort((a,b) => (a[1] - a[0]) - (b[1] - b[0]) || a[0]-b[0])[0];
}

원래 전부 실패했던 효율성이 어느정도 통과하게된다

번외

Object.keys대신 for...in을 사용해보았다.

		const temp = [];
        for(const key in obj){
            temp.push(obj[key]);
        }

2개는 통과

결론

=> Object.keys나 for...in같이 배열화 하는 메서드 보다 이터레이터가 훨씬 빠르다