잡다한 배똥월드

function solution(id_list, report, k) {
    let answer = new Array();
    let list = new Array();
    let count = new Array();
    
	//자바스크립트의 배열의 경우 자료형을 정해놓지 않고 선언하기 때문에 한 번은 값을 넣어줘야 나중에 null이 생기지 않음
    for (let i = 0; i < id_list.length; i++) {
        list[id_list[i]] = new ID(); //유저가 신고한 아이디를 담기 위한 배열
        count[id_list[i]] = 0; //유저의 신고 당한 수를 카운트하기 위한 배열
        answer[i] = 0; //유저가 신고한 아이디가 정지된 개수
    }
    
    for (let i = 0; i < report.length; i++) {
        let s = report[i].split(" "); //띄어쓰기로 구분되어 있기 때문에 split으로 문자열 나누기
        
		//만약 유저가 신고한 적 있는 아이디면 continue
        if (list[s[0]].check(s[1])) continue;
	      
		//없으면 배열에 추가하고 신고 당한 수 +1
        list[s[0]].add(s[1]);
        count[s[1]]++;
    }
    
	//id_list 순서로 해당 유저가 신고한 아이디가 k를 넘었는지 체크
    for (let i = 0; i < id_list.length; i++) {
        let arr = list[id_list[i]].arr;
		    
        for (let j = 0; j < arr.length; j++) {
            if (count[arr[j]] >= k) answer[i]++;
        }
    }
    return answer;
}

//ID라는 객체 생성해서 배열을 만들었음
class ID {
    constructor(){
        this.arr = new Array();
    }
    
    add = function(name) {
        this.arr.push(name);
    }
    
    check = function(name) {
        if (this.arr.indexOf(name) != -1) return true;
        return false;
    }
}

var answer;
function solution(number, k) {
    answer = new Array();
    var num = new Array();
    
    for (let i = 0; i < number.length; i++) {
        num[i] = Number(number.substring(i, i+1));
    }
    
    var start = 0;
    var count = num.length - k;
    
    while (count > 0) {
        start = func(num, start, count);
        count--;
    }
    
    return answer.join('');
}

function func(n, start, count) {
    var max = '0';
    var index = start;
    for (let i = start; i <= n.length - count; i++) {
        if (max < n[i]) {
            max = n[i];
            index = i;
        }
    }
    
    answer.push(max);
    return index + 1;
}

▽ 자세한 설명이 필요할 경우 자바 코드 설명을 참고하세요 ▽

function solution(brown, yellow) {
    for (let i = 1; i <= yellow / i; i++) {
        if (yellow % i != 0) continue;
        
        let num = yellow / i;
        if ((num + 2) * 2 + i * 2 == brown) return [num+2, i+2];
    }
    
    return [0, 0];
}

▽ 자세한 설명이 필요하다면 ▽

function solution(citations) {
    let answer = 0;
    let size = citations.length;
    
    for (let i = size; i >= 1; i--) {
        let count = 0;
        for (let j = 0; j < size; j++) {
            if (citations[j] >= i) count++;
        }
        
        if (count >= i && size - count <= i) {
            answer = i;
            break;
        }
    }
    return answer;
}

코드 참고용

function solution(operations) {
    let min = new MinHeap();
    let max = new MaxHeap();
    
    for (let i = 0; i < operations.length; i++) {
        let s = operations[i].split(" ");
        
        if (s[0] === "I") {
            let num = parseInt(s[1]);
            min.add(num);
            max.add(num);
        } else {
            if (s[1] == "1") {
                max.delete();
            } else {
                min.delete();
            }
            
            if (min.length() == 1 || max.length() == 1 || min.top() > max.top()) {
                min = new MinHeap();
                max = new MaxHeap();
            }
        }
    }
    
    return min.length() == 1 || max.length() == 1 ? [0, 0] : [max.top(), min.top()];
}

class MinHeap {
    constructor(){
        this.list = [];
        this.list.push(0);
    }

    add = function(num) {
        this.list.push(num);
        var position = this.list.length-1;
        while(position > 1 && this.list[parseInt(position/2)] > this.list[position]) {
            var parent = parseInt(position / 2);
            
            var temp = this.list[position];
            this.list[position] = this.list[parent];
            this.list[parent] = temp;
            position = parent;
        }
    }
    
    delete = function(num) {
        if (this.list.length == 1) return;
        if (this.list.length == 2) return this.list.pop();
        
        let result = this.list[1];
        
        this.list[1] = this.list.pop();
        let position = 1;
        
        while (position * 2 < this.list.length) {
            let min = this.list[position*2];
            let minPosition = position * 2;
            
            if (minPosition + 1 < this.list.length && min > this.list[minPosition+1]) {
                min = this.list[minPosition+1];
                minPosition += 1;
            }
            
            if (this.list[position] < min) break;
            
            let temp = this.list[position];
            this.list[position] = min;
            this.list[minPosition] = temp;
            
            position = minPosition;
        }
    }
    
    top = function() {
        return this.list[1];
    }
    
    length = function() {
        return this.list.length;
    }
}

class MaxHeap {
    constructor(){
        this.list = [];
        this.list.push(0);
    }

    add = function(num) {
        this.list.push(num);
        var position = this.list.length-1;
        while(position > 1 && this.list[parseInt(position/2)] < this.list[position]) {
            var parent = parseInt(position / 2);
            
            var temp = this.list[position];
            this.list[position] = this.list[parent];
            this.list[parent] = temp;
            position = parent;
        }
    }
    
    delete = function(num) {
        if (this.list.length == 1) return;
        if (this.list.length == 2) return this.list.pop();
        
        let result = this.list[1];
        
        this.list[1] = this.list.pop();
        let position = 1;
        
        while (position * 2 < this.list.length) {
            let max = this.list[position*2];
            let maxPosition = position * 2;
            
            if (maxPosition + 1 < this.list.length && max < this.list[maxPosition+1]) {
                max = this.list[maxPosition+1];
                maxPosition += 1;
            }
            
            if (this.list[position] > max) break;
            
            let temp = this.list[position];
            this.list[position] = max;
            this.list[maxPosition] = temp;
            
            position = maxPosition;
        }
    }
    
    top = function() {
        return this.list[1];
    }
    
    length = function() {
        return this.list.length;
    }
}

우선순위큐를 자바스크립트에선 사용해본 적도 없어서.. 그냥 생성자를 이용해서 최소힙과 최대힙을 구현했다.

function solution(operations) {
    let list = new Array();
    
    for (let i = 0; i < operations.length; i++) {
        let s = operations[i].split(" ");
        if (s[0] == "I") {
            list.push(parseInt(s[1]));
            list.sort(function(a, b) {
                return a - b;
            });
        } else {
            if (s[1] == "1") {
                list.pop();
            } else {
                list.shift();
            }
        }
    }
    return list.length == 0 ? [0, 0] : [list[list.length-1], list[0]];
}

근데 그냥 데이터 추가할 때마다 정렬해도 시간 초과 안뜨네... 쩝;;

function solution(bridge_length, weight, truck_weights) {
    let time = 0;
    let position = 0;
    let w = 0;
    
    let bridge = new Array();
    let finished = 0;
    
    while (finished < truck_weights.length) {
        time++;
        
        if (bridge.length == bridge_length) {
            let num = bridge.shift();
            if (num != -1) {
                w -= num;
                finished++;
            }
        }
        if (position < truck_weights.length && truck_weights[position] + w <= weight) {
            w += truck_weights[position];
            bridge.push(truck_weights[position]);
            position++;
        } else {
            bridge.push(-1);
        }
    }
    
    return time;
}

자세한 설명은 같은 문제 Java로 풀었을 때의 코드를 참고하세요!

function solution(clothes) {
    var answer = 1;
    let hash = new Array();
    
    for (var i = 0; i < clothes.length; i++) {
        if (hash[clothes[i][1]] == null) hash[clothes[i][1]] = 0;
        hash[clothes[i][1]]++;
    }
    
    for (let key in hash) {
        answer *= hash[key] + 1;
    }
    return answer - 1;
}

자세한 설명은 자바 코드에서 확인 가능!

function solution(n) {
    let list = new Array();
    list[1] = 1;
    list[2] = 2;
    
    for (var i = 3; i <= n; i++) {
        list[i] = (list[i-1] + list[i-2]) % 1000000007;
    }
    
    return list[n];
}

자세한 설명은 자바 코드에 작성되어 있음