잡다한 배똥월드

링크 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];
}

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

class Solution {
    public int[] solution(int brown, int yellow) {
        for (int i = 1; i <= yellow / i; i++) {
            if (yellow % i != 0) continue;
            int num = yellow / i;
            if ((num + 2) * 2 + i * 2 == brown) return new int[]{num+2, i+2}; 
        }
        
        return new int[]{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;
}

코드 참고용

class Solution {
    public int solution(int[] citations) {
        int answer = 0;
        int size = citations.length; //n편
        
        for (int i = citations.length; i >= 1; i--) { //h번 카운트용 for문
            int count = 0; //h번 이상 인용된 논문 카운트용
            for (int j = 0; j < citations.length; j++) { //for문으로 확인
                if (citations[j] >= i) count++; //j번 논문이 i번 이상 인용됬다면 count+1
            }
            
            //만약 i번 이상 인용된 논문의 수가 i개 이상이고, 그렇지 않은 논문의 수가 i개 이하면
            if (count >= i && size - count <= i) {
            	//h-index인데, 큰 값에서 줄어들고 있기 때문에 가장 먼저 나온 값이 최대값
                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]];
}

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

import java.util.*;
class Solution {
    public int[] solution(String[] operations) {
        
        //최소값 기준 우선순위 큐
        PriorityQueue<Integer> minQ = new PriorityQueue<>();
        
        //최대값 기준 우선순위 큐
        PriorityQueue<Integer> maxQ = new PriorityQueue<>(Collections.reverseOrder());
        
        for (int i = 0; i < operations.length; i++) {
            String[] s = operations[i].split(" ");
            if (s[0].equals("I")) { //만약 I면 minQ와 maxQ에 각각 숫자 추가
                int num = Integer.parseInt(s[1]);
                minQ.add(num);
                maxQ.add(num);
            } else { //만약 D면
                if (s[1].equals("1")) { //1일 경우에는 최대값에서 값 지우고
                    maxQ.poll();
                } else { //그렇지 않을 경우에는 최소값에서 값 지우기
                    minQ.poll();
                }
                
                //만약 minQ나 maxQ에 지울 것이 없거나, minQ의 첫번째 값이 maxQ의 첫번째 값보다 클 경우
                if (minQ.size() == 0 || maxQ.size() == 0 || minQ.peek() > maxQ.peek()) {
                	//minQ, maxQ 리셋
                    minQ = new PriorityQueue<>();
                    maxQ = new PriorityQueue<>(Collections.reverseOrder());
                }
            }
        }
        
        //minQ와 maxQ가 비어있다면 0, 0 리턴, 그렇지 않으면 각 최대값, 최소값 리턴
        return minQ.size() == 0 || maxQ.size() == 0 ? new int[]{0, 0} : new int[]{maxQ.peek(), minQ.peek()};
    }
}

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로 풀었을 때의 코드를 참고하세요!