잡다한 배똥월드

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

import java.util.*;
class Solution {
    public int[] solution(int[] numbers) {
    	//더한 값들을 담을 배열 선언
        ArrayList<Integer> arr = new ArrayList<>();
        
        //0번부터 number.length-1까지 방문하는 for문
        for (int i = 0; i < numbers.length; i++) {
        	//i번의 다음 순서부터 number.length-1가지 방문하는 for문
            for (int j = i+1; j < numbers.length; j++) {
            
            	//두 숫자를 더한 값이 arr에 없으면 추가하고 아니면 그냥 넘어가기
                int num = numbers[i] + numbers[j];
                if (arr.indexOf(num) == -1) arr.add(num);
            }
        }
        
        //ArrayList 오름차순 정렬
        Collections.sort(arr);
        
        //ArrayList를 int[]로 변환하면서 리턴
        return arr.stream().mapToInt(Integer::intValue).toArray();
    }
}

import java.util.*;

class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];
        int[] arrival = new int[N+1];  //스테이지별 도달한 플레이어 수
        int[] noClear = new int[N+1];  //스테이지별 클리어하지 못한 플레이어 수
        
        //도달한 플레이어 수 구하기
        //stages[j](멈춰있는 스테이지)가 i(스테이지 레벨)보다 크거나 같으면 +1
        for (int i = 1; i <= N; i++) { 
            for (int j = 0; j < stages.length; j++) {
                if (stages[j] >= i) arrival[i]++; 
            }
        }
        
        //도달은 했지만 클리어하지 못한 플레이어 수 구하기
        //stages[i]의 해당 스테이지 +1
        for (int i = 0; i < stages.length; i++) {
            if (stages[i] > N) continue;
            noClear[stages[i]]++;
        }
        
        //해시맵에 스테이지와 해당 스테이지의 실패율 저장
        HashMap<Integer, Double> map = new HashMap<>();
        for (int i = 1; i <= N; i++) {
            if (arrival[i] == 0)
                map.put(i, (double) 0);
            else 
                map.put(i, (double) noClear[i] / arrival[i]);
                
        }
        
       	//실패율(내림차순)로 정렬
        //실패율이 동일하면 스테이지 레벨이 작은 것이 앞으로 오게(오름차순) 정렬
        List<Map.Entry<Integer, Double>> arr = new ArrayList<Map.Entry<Integer, Double>>(map.entrySet());
        Collections.sort(arr, new Comparator<Map.Entry<Integer, Double>>(){
            @Override
            public int compare(Map.Entry<Integer, Double> o1, Map.Entry<Integer, Double> o2) {
                double v1 = o1.getValue();
                double v2 = o2.getValue();
                
                if (v1 < v2) {
                    return 1;
                } else if (v1 == v2) {
                    if (o1.getKey() > o2.getKey()) {
                        return 1;
                    }
                }
                
                return -1;
            }
        });
        
        for (int i = 0; i < arr.size(); i++) {
            answer[i] = arr.get(i).getKey();
        }
        
        return answer;
    }
}

이게 1단계..?

문제를 풀면서 주의해야할 점은 도달한 플레이어 수가 0인 스테이지는 실패율을 0으로 제대로 처리해야 한다

직접 값을 입력하지 않으면 0으로 나누는 것이 되기 때문에 오류가 뜨기 때문이다.

import java.util.*;

class Solution {
    public int solution(int[] nums) {
        HashMap<Integer, Integer> list = new HashMap<>();
        
        for (int i = 0; i < nums.length; i++) {
            list.put(nums[i], list.getOrDefault(nums[i], 0) + 1);
        }
        
        return (nums.length / 2 > list.size()) ? list.size() : nums.length / 2;
    }
}

해시맵으로 폰켓몬 종류가 몇 종류인지 파악하고

종류 수와 nums / 2 중에서 작은 숫자를 리턴하면 되는데, Math.min( )으로 처리하려고 보니까 시간이 조금 더 길어지길래 그냥 삼항연산자로 처리함

import java.util.*;
class Solution {
    public int[] solution(int[] answers) {
        int[] case1 = {1, 2, 3, 4, 5};
        int[] case2 = {2, 1, 2, 3, 2, 4, 2, 5};
        int[] case3 = {3, 3, 1, 1, 2, 2, 4, 4, 5, 5};
        int[] position = new int[3];
        int[] pass = new int[3];
        
        int max = 0;
        for (int i = 0; i < answers.length; i++) {
            pass[0] += (case1[position[0]] == answers[i]) ? 1 : 0;
            pass[1] += (case2[position[1]] == answers[i]) ? 1 : 0;
            pass[2] += (case3[position[2]] == answers[i]) ? 1 : 0;
            
            
            position[0] = position[0] + 1 == case1.length ? 0 : position[0] + 1; 
            position[1] = position[1] + 1 == case2.length ? 0 : position[1] + 1; 
            position[2] = position[2] + 1 == case3.length ? 0 : position[2] + 1; 
            
        }
        max = Math.max(pass[0], Math.max(pass[1], pass[2]));
        
        ArrayList<Integer> arr = new ArrayList<>();
        
        for (int i = 0; i < 3; i++) {
            if (pass[i] == max) arr.add(i+1);
        }
        
        return arr.stream().mapToInt(Integer::intValue).toArray();
    }
}

import java.util.*;

class Solution {
    public int[] solution(int[] array, int[][] commands) {
        int[] answer = new int[commands.length];
        
        for (int i = 0; i < commands.length; i++) {
            int[] arr = Arrays.copyOfRange(array, commands[i][0]-1, commands[i][1]);
            Arrays.sort(arr);
            
            answer[i] = arr[commands[i][2]-1];
        }
        return answer;
    }
}

범위를 지정해서 배열을 자르는 copyOfRange를 이용해서 자른 후 정렬한 다음에

원하는 위치의 숫자를 가져오면 됨

import java.util.*;

class Solution {
    public String solution(String[] participant, String[] completion) {
        HashMap<String, Integer> name = new HashMap<>();
        String answer = "";
        
        for (int i = 0; i < completion.length; i++) {
            name.put(completion[i], name.getOrDefault(completion[i], 0) + 1);
        }
        
        for (int i = 0; i < participant.length; i++) {
            int num = name.getOrDefault(participant[i], 0);
            
            if (num == 0) {
                answer = participant[i];
                break;
            }
            
            name.put(participant[i], num - 1);
        }
        
        return answer;
    }
}

completion에 있는 이름들을 해시맵에 넣고, participant에 있는 이름을 하나씩 지워간다.

만약 getOrDefault()가 0을 리턴하면 그대로 그냥 answer에 이름 넣고 종료.

class Solution {
    
    boolean[] check;
    int answer;
    
    public int solution(int[] nums) {
        answer = 0;
        
        check = new boolean[nums.length];
        
        func(nums, 0, 0, 0);

        return answer;
    }
    
    public void func(int[] arr, int num, int index, int position) {
        if (index == 3) {
            boolean value = true;
            
            for (int i = 2; i < num; i++) {
                if (num % i == 0) {
                    value = false;
                    break;
                }
            }
            
            if (value) answer++;
            
            return;
        }
        
        for (int i = position; i < arr.length; i++) {
            if (check[i]) continue;
            
            check[i] = true;
            func(arr, num+arr[i], index+1, i+1);
            check[i] = false;
        }
    }
}

DP인가..? 어쨋든 하나씩 다녀오면서 숫자 3개를 더했는지 확인하고 더했으면 소수인지 확인 후 계산