잡다한 배똥월드

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

import java.util.*;
class Solution {
    public int solution(int bridge_length, int weight, int[] truck_weights) {
        
        int w = 0; //다리 위에 있는 트럭의 무게
        int time = 0; //걸린 시간
        int position = 0; //지나야할 트럭의 순서를 기록
        
        ArrayList<Integer> bridge = new ArrayList<>(); //다리 위의 모습을 표현할 용도
        int finished = 0; //지난 트럭의 갯수
        
        //다리를 지난 트럭의 수가 총 트럭 수보다 작을 동안만 반복
        while (finished < truck_weights.length) { 
            time++; //시간+1
            
            다리 위에 있는 트럭이 length와 같다면 한 개씩은 앞에서부터 지워줘야 함
            if (bridge.size() == bridge_length) {
                int num = bridge.remove(0); //제일 앞에 있는 트럭 제거
                if (num != -1) { //만약 num이 -1이 아니면 무게가 있는 트럭이라는 뜻이기 때문에
                    w -= num; //다리 위에 있는 트럭의 무게에서 현재 다 지나온 트럭의 무게 빼주고
                    finished++; //통과한 트럭의 개수는 추가
                }
            }
            
            //아직 다리위에 올라가지 않은 트럭이 있고,
            //그 무게가 현재 다리 위에 있는 트럭의 무게와 더해도 감당할 수 있는 무게라면 다리 위로 올림
            if (truck_weights.length > position && w + truck_weights[position] <= weight) {
                w += truck_weights[position];
                bridge.add(truck_weights[position]);
                position++;
            } else { //그렇지 않으면 그냥 빈 칸 추가
                bridge.add(-1);
            }
        }
        
        return time; //마지막에 걸린 시간 리턴하기
    }
}

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;
}

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

import java.util.*;
class Solution {
    public int solution(String[][] clothes) {
        HashMap<String, Integer> hash = new HashMap<>();
        
        //곱셈을 해야 해서 1부터 시작
        int answer = 1;
        
        //종류별로 해시에 모으기
      	//이름은 상관 없기 때문에 숫자로 계산
        for (int i = 0; i < clothes.length; i++) {
            hash.put(clothes[i][1], hash.getOrDefault(clothes[i][1], 0) + 1);
        }
        
        //1을 더하는 이유는 해당 옷을 입지 않는 경우를 포함해야 하기 때문임
        for (String key : hash.keySet()) {
            answer *= hash.get(key) + 1;
        }
        
        //모두 착용하지 않는 경우는 제외해야 하기 때문에 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];
}

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