💪🏻 programmers Lv1(24.11.14 -3문제)

65) 실패율

1. HashMap 사용해서 Key 값에는 스테이지 번호, value 값에 실패율 넣기

2. value 값을 기준으로 내림차순 정렬하고 key 값을 새로운 배열에 넣어보기

import java.util.*;
class Solution {
    public int[] solution(int N, int[] stages) {
        int[] answer = new int[N];
        double[] fail = new double[N];
        Map<Integer, Double> map = new HashMap<>();
        
        for(int i=1;i<=N;i++)
        {
            double failureLate = 0; //실패율
            double failCnt = 0; // 실패한 플레이어 수
            double sucCnt = 0; // 도달한 플레이어 수
            
            for(int j=0;j<stages.length;j++)
            {
                if(stages[j]==i)
                {
                    failCnt++; //클리어하지 못한 플레이어 수
                }
                if(stages[j]>=i)
                {
                    sucCnt++; // 스테이지에 도달한 플레이어 수
                }
            }
            map.put(i, failCnt/sucCnt);
            if(failCnt == 0 && sucCnt == 0)
                map.put(i,0.0);
        }
        
        List<Integer> list = new ArrayList<>(map.keySet());
        list.sort((o1, o2)-> map.get(o2).compareTo(map.get(o1)));
        
        for(int i=0;i<N;i++)
        {
            answer[i] = list.get(i);
        }
        
        
        return answer;
    }
}

Map<Integer, Double> map = new HashMap<>();와 HashMap<Integer, Double> map = new HashMap<>(); 차이는 변수 선언 시 사용하는 참조 타입에 있다.

Map은 HashMap의 인터페이스로 Map 타입으로 선언하는 경우, 이후에 코드에서 HashMap 외에 다른 Map 구현체(TreeMap, LinkedHashMap 등)로 쉽게 교체할 수 있다.

• Map 인터페이스로 선언하는 것이 일반적으로 권장된다. 인터페이스 타입으로 선언하면 코드가 더 유연하고 확장성이 좋다.

• 만약 HashMap의 특정 기능에 의존하는 코드를 작성할 때는 HashMap 타입으로 선언해도 괜찮다.

List<Integer> list = new ArrayList<>(map.keySet()); 코드는 키들의 집합(Set)을 리스트(ArrayList)로 변환해서 키들을 리스트 형태로 저장하게 된다.

list.sort((o1, o2) -> map.get(o2).compareTo(map.get(o1))); 는 내림차순을 나타낸다.

list.sort((o1, o2) -> map.get(o1).compareTo(map.get(o2))); 는 오름차순을 나타낸다.

---

HashMap

데이터를 저장할 때 키(Key), 밸류(Value)가 짝을 이루어 저장된다. 데이터를 저장할 때는 키(Key) 값으로 해시함수를 실행한 결과를 통해 저장 위치를 결정한다.

따라서 HashMap은 특정 데이터의 저장 위치를 해시 함수를 통해 바로 알 수 있기 때문에 데이터의 추가, 삭제, 특히 검색이 빠르다는 장점이 있다.

때문에 HashMap은 키(Key) 값을 통해서만 검색이 가능하며 키(key) 값은 중복될 수 없고 밸류(value) 값은 키(key) 값이 다르면 중복이 가능하다.

• 선언

HashMap<Integer> map = new HashMap<>();

• 값 추가

map.put(1,"마루");
map.put(2,"두유");

• 값 삭제

map.remove(1); // key 값 1 제거
map.clear(); // 모든 값 제거

• 값 출력

System.out.println(map.get(2)); // 두유

//entrySet() 활용
for (Entry<Integer, String> entry : map.entrySet()) {
	System.out.println("[Key]:" + entry.getKey() + " [Value]:" + entry.getValue());
}

//KeySet() 활용
for(Integer i : map.keySet()){ //저장된 key값 확인
	System.out.println("[Key]:" + i + " [Value]:" + map.get(i));
}

//keySet().iterator()
Iterator<Integer> keys = map.keySet().iterator();
while(keys.hasNext()){
	int key = keys.next();
	System.out.println("[Key]:" + key + " [Value]:" + map.get(key));
}

entrySet()은 key와 value 모두가 필요할 경우 사용하고 keySet()은 key 값만 필요한 경우 사용한다.

반복문을 사용하지 않고 Iterator()를 사용해도 된다.

66) [PCCE 기출문제] 9번 / 지폐 접기

1. 지폐를 접은 횟수를 저장할 정수 변수 answer를 만들고 0을 저장합니다.
2. 반복문을 이용해 bill의 작은 값이 wallet의 작은 값 보다 크거나 bill의 큰 값이 wallet의 큰 값 보다 큰 동안 아래 과정을 반복합니다. 2-1. bill[0]이 bill[1]보다 크다면 bill[0]을 2로 나누고 나머지는 버립니다. 2-2. 그렇지 않다면 bill[1]을 2로 나누고 나머지는 버립니다. 2-3. answer을 1 증가시킵니다.
3. answer을 return합니다.

import java.util.*;
class Solution {
    public int solution(int[] wallet, int[] bill) {
        int answer = 0;
        
        Arrays.sort(wallet);
        Arrays.sort(bill);
        
        while(!fit(wallet, bill))
        {
            if(bill[0]>bill[1])
            {
                bill[0]/=2;
            }
            else{
                bill[1]/=2;
            }
            Arrays.sort(bill);
            answer++;
        }
        
        return answer;
    }
    public static boolean fit(int[] wallet, int[] bill)
    {
        return (bill[0]<=wallet[0] && bill[1] <=wallet[1]);
    }
}

67) 다트 게임

import java.util.*;
class Solution {
    public int solution(String dartResult) {
        int answer = 0;
        int[] arr = new int[3];
        int idx = 0;
        String s = "";
        for(int i=0;i<dartResult.length();i++)
        {
            switch(dartResult.charAt(i))
            {
                case '*':
                    arr[idx-1]*=2;
                    if(idx>1)
                    {
                        arr[idx-2]*=2;
                    }
                    break;
                
                case '#':
                    arr[idx-1]*=-1;
                    break;
                case 'S':
                    arr[idx] = (int)Math.pow(Integer.parseInt(s),1);
                    idx++;
                    s = "";
                    break;
                case 'D':
                    arr[idx] = (int)Math.pow(Integer.parseInt(s),2);
                    idx++;
                    s = "";
                break;
                case 'T':
                    arr[idx] = (int)Math.pow(Integer.parseInt(s),3);
                    idx++;
                    s = "";
                break;
                
                default:
                    s+=String.valueOf(dartResult.charAt(i));
                    break;
            }
        }
        for(int i=0;i<arr.length;i++)
        {
            answer+=arr[i];
        }
        return answer;
    }
}