아찌방 하우스

문제 설명

코드

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

class Solution {
    public String solution(String[] participant, String[] completion) {
        String answer = "";
        HashMap<String, Integer> map = new HashMap<>();
       
        for (String c:completion){ //해시맵에 완주자 목록을 넣기위해
            if(map.get(c) != null) // 동명이인을 위해
            {
                map.put(c,map.get(c)+1);
            }
            else
                map.put(c,1);
        }
        
        for (String p:participant)  
        {
            if(map.get(p) == null || map.get(p) == 0) //완주자 목록에 없거나 동명이인 중 못들어온 사람이 있는 경우
            {
                answer = p;
            }
            else if(map.get(p) >= 1) //완주한게 확인 되면 value 값에 -1
            {
                map.put(p, map.get(p)-1);
            }
        }
        return answer;
    }
}

의도

 HasMap을 하도 안 쓰다보니 다시 공부하고 코딩을 했다.

HasMap 선언 후  완주자 목록을 집어 넣는다. key = 완주자 이름, value은 완주자 한 명당 1씩 증가.

그 후 key 가 참가자(participant) 목록에 있으면 -1을 해준다.

또는 참가자(participant) 목록에 없거나(Null) value 값이 0이면 그 참가자가 미완주자이다.

결과

문제 설명

코드

import java.util.Arrays;
class Solution {
    public int[] solution(int[] array, int[][] commands) {
        int[] answer = new int[commands.length]; //commands의 row 값만큼 배정
        
        for(int i = 0; i < commands.length; i++) //commands의 row 값만큼 반복
        {
            int how = (commands[i][1] - commands[i][0]) + 1; // n1~n2까지의 길이를 배정
            int[] temp = new int[how]; // n1~n2까지를 임시로 저장해줄 배열
            int count =0;
            for(int j = commands[i][0]-1; j <= commands[i][1]-1; j++) //n1~n2까지 
            {
                temp[count] = array[j]; //임시저장
                count++; //temp의 좌표 이동
            }
            Arrays.sort(temp); //정렬
            answer[i] = temp[commands[i][2]-1]; //저장
        }
        return answer;
    }
}

의도

결과

다른 사람의 코드

import java.util.Arrays;
class Solution {
    public int[] solution(int[] array, int[][] commands) {
        int[] answer = new int[commands.length];

        for(int i=0; i<commands.length; i++){
            int[] temp = Arrays.copyOfRange(array, commands[i][0]-1, commands[i][1]);
            Arrays.sort(temp);
            answer[i] = temp[commands[i][2]-1];
        }

        return answer;
    }
}

copyOfRange 써서 코드를 단축시켰다. 근데 실행시간은 그렇게 달라지지 않는다.

class Solution {
    public int[] solution(int[] array, int[][] commands) {
        int n = 0;
        int[] ret = new int[commands.length];

        while(n < commands.length){
            int m = commands[n][1] - commands[n][0] + 1;

            if(m == 1){
                ret[n] = array[commands[n++][0]-1];
                continue;
            }

            int[] a = new int[m];
            int j = 0;
            for(int i = commands[n][0]-1; i < commands[n][1]; i++)
                a[j++] = array[i];

            sort(a, 0, m-1);

            ret[n] = a[commands[n++][2]-1];
        }

        return ret;
    }

    void sort(int[] a, int left, int right){
        int pl = left;
        int pr = right;
        int x = a[(pl+pr)/2];

        do{
            while(a[pl] < x) pl++;
            while(a[pr] > x) pr--;
            if(pl <= pr){
                int temp = a[pl];
                a[pl] = a[pr];
                a[pr] = temp;
                pl++;
                pr--;
            }
        }while(pl <= pr);

        if(left < pr) sort(a, left, pr);
        if(right > pl) sort(a, pl, right);
    }
}

이 분은 sort 부분을 함수로 직접 구현하셨고 copyOfRange도 직접 구현하셨다.