문제 설명

Leo는 카펫을 사러 갔다가 아래 그림과 같이 중앙에는 노란색으로 칠해져 있고 테두리 1줄은 갈색으로 칠해져 있는 격자 모양 카펫을 봤습니다.

Leo가 본 카펫에서 갈색 격자의 수 brown, 노란색 격자의 수 yellow가 매개변수로 주어질 때 카펫의 가로, 세로 크기를 순서대로 배열에 담아 return 하도록 solution 함수를 작성해주세요.

나의 풀이 (java)

class Solution {
    public int[] solution(int brown, int yellow) {
//        수학적 풀이 필요 (1.for문 사용 2.근의공식) => 1로 풀었지만, 2가 성능이 좋음
//        yellow*brown = 가로*세로
//        yellow = (가로-2)*(세로-2)
        int[] answer = new int[2];
        for (int tempWidth = yellow+2; tempWidth > 0; tempWidth--) {
            int tempHeight = (brown+yellow)/tempWidth;
            if((tempWidth-2) * (tempHeight-2) == yellow){
                answer[0]=tempWidth;
                answer[1]=tempHeight;
                break;
            }
        }
        return answer;
    }
}

풀이 방법

• 수학적 풀이 필요 (1.for문 사용 2.근의공식) => 1로 풀었지만, 2가 성능이 좋음
  • yellow*brown = 가로*세로
  • yellow = (가로-2)*(세로-2)

다른사람의 풀이 (java)

Good Idea : 근의 공식을 구현해 계산 -> 그렇다면, for문을 돌리지않고, 계산식만 한번 구하면 되기 때문에 성능이 아주 좋음 (단 가독성은 좀 떨어질수도..)

느낀점

코테에서는 종종 수학적 접근법이 중요한 경우가 있다.

그렇지 않으면, 모든 경우를 뒤져보면 된다

문제 설명

명함 지갑을 만드는 회사에서 지갑의 크기를 정하려고 합니다. 다양한 모양과 크기의 명함들을 모두 수납할 수 있으면서, 작아서 들고 다니기 편한 지갑을 만들어야 합니다. 이러한 요건을 만족하는 지갑을 만들기 위해 디자인팀은 모든 명함의 가로 길이와 세로 길이를 조사했습니다.

아래 표는 4가지 명함의 가로 길이와 세로 길이를 나타냅니다.

명함 번호 가로 길이 세로 길이
1 60 50
2 30 70
3 60 30
4 80 40
가장 긴 가로 길이와 세로 길이가 각각 80, 70이기 때문에 80(가로) x 70(세로) 크기의 지갑을 만들면 모든 명함들을 수납할 수 있습니다. 하지만 2번 명함을 가로로 눕혀 수납한다면 80(가로) x 50(세로) 크기의 지갑으로 모든 명함들을 수납할 수 있습니다. 이때의 지갑 크기는 4000(=80 x 50)입니다.

모든 명함의 가로 길이와 세로 길이를 나타내는 2차원 배열 sizes가 매개변수로 주어집니다. 모든 명함을 수납할 수 있는 가장 작은 지갑을 만들 때, 지갑의 크기를 return 하도록 solution 함수를 완성해주세요.

나의 풀이 (java)

class Solution {
    public int solution(int[][] sizes) {
        int max = 0;
        int min = 0;
        for (int[] size : sizes) {
            int paramMax = Math.max(size[0], size[1]);
            int paramMin = Math.min(size[0], size[1]);

            if (paramMax > max) {
                max = paramMax;
            }

            if (paramMin > min) {
                min = paramMin;
            }
        }
        return max * min;
    }
}

풀이 방법

• 모든 지갑마다 가로>세로 되도록 "sizes"를 정렬
• 게중에 가장 큰 가로/세로 길이를 구함

느낀점

모든 경우의 수를 확인해야하는 완전 탐색의 풀이법은

역시 반복문과 조건문으로 빠짐없이 모두 체크하는것!

문제 설명

하드디스크는 한 번에 하나의 작업만 수행할 수 있습니다. 디스크 컨트롤러를 구현하는 방법은 여러 가지가 있습니다. 가장 일반적인 방법은 요청이 들어온 순서대로 처리하는 것입니다.
각 작업에 대해 [작업이 요청되는 시점, 작업의 소요시간]을 담은 2차원 배열 jobs가 매개변수로 주어질 때, 작업의 요청부터 종료까지 걸린 시간의 평균을 가장 줄이는 방법으로 처리하면 평균이 얼마가 되는지 return 하도록 solution 함수를 작성해주세요. (단, 소수점 이하의 수는 버립니다)

나의 풀이 (java) = 다른 사람의 풀이

import java.util.Arrays;
import java.util.PriorityQueue;

class Solution {
    public int solution(int[][] jobs) {
        // 총 시간은 대기시간(가변)+실행시간(불변)이므로, 대기시간이 짧을수록 짧아진다
        // 대기시간(=시작시간-요청시간)을 짧게 하려면, 수행시간이 짧은걸 먼저 처리(SJF)

        // 중요 개념 : 선점SJF 와 비슷
        // 작업을 요청 시점 순으로 담고 있는 작업 큐
        // 소요시간이 적은 순으로 작업을 수행하는 작업 큐
        // 요청 시점에 가능한 작업들을 작업 큐에 넘겨주면, 소요시간이 적은 순서대로 우선순위를 부여하여 작업을 수행

        int seconds = 0;
        // jobs를 요청시간으로 정렬(asc)하는 prioirtyQueue 생성
        PriorityQueue<Integer[]> jobQue = new PriorityQueue<>((o1, o2) -> o1[0].compareTo(o2[0]) );

        // int[] -> Integer[] -> prioirtyQueue에 삽입
        for (int[] job : jobs) {
            jobQue.add(Arrays.stream(job).boxed().toArray(Integer[]::new));
        }

        // 계산
        int size = jobQue.size();
        int totalSeconds = 0;
        while(!jobQue.isEmpty()){
            if(seconds < jobQue.peek()[0]){
                seconds++;
                continue;
            }

            // 해당 시점에 실행할 수 있는 job관리 큐
            PriorityQueue<Integer[]> availableQue = new PriorityQueue<>((o1,o2) -> o1[1].compareTo(o2[1]));
            while(!jobQue.isEmpty() && jobQue.peek()[0] <= seconds){
                availableQue.add(jobQue.poll());
            }

            // 대기시간(=시작시간-요청시간) + 실행시간
            Integer[] currentJob = availableQue.poll();
            totalSeconds += seconds - currentJob[0] + currentJob[1];

            // 쓰지 않은 job은 모두 복구
            jobQue.addAll(availableQue);

            // 현재 작업 실행 완료 시점으로 jump!
            seconds += currentJob[1];
        }

        return Math.round(totalSeconds/size);
    }
}

풀이 방법

• 선점 SJF와 비슷 = 작업을 요청 시점 순으로 담아서 처리
  • 잘못된 접근 : 작업시작 시간으로 정렬하는것에 집중한것이 실패의 요인
  • 올바른 접근 : 당시의 최적의 해를 구하는 탐욕법과 비슷
    => 매 시점마다 소요시간이 적게 걸리는 작업을 먼저 처리하는게 효율적이라는 풀이를 도출하는것이 중요하다
• 풀이
  • 작업 요청 시간 별로 정렬-> 첫번째 실행 -> 완료 시점에서 실행가능한 작업중 완료시간이 가장 짧은 작업 실행 * n 번 실행

느낀점

• 그리디(탐욕법) : 당시의 최적의해를 찾는 방식을 계속하는 방식 -> 이 내용과 비슷
• 주요 로직
  작업 요청 시간 별로 정렬-> 첫번째 실행 -> 완료 시점에서 실행가능한 작업중 완료시간이 가장 짧은 작업 실행 * n 번 실행

문제 설명

이중 우선순위 큐는 다음 연산을 할 수 있는 자료구조를 말합니다.

명령어 수신 탑(높이)
I 숫자 큐에 주어진 숫자를 삽입합니다.
D 1 큐에서 최댓값을 삭제합니다.
D -1 큐에서 최솟값을 삭제합니다.
이중 우선순위 큐가 할 연산 operations가 매개변수로 주어질 때, 모든 연산을 처리한 후 큐가 비어있으면 [0,0] 비어있지 않으면 [최댓값, 최솟값]을 return 하도록 solution 함수를 구현해주세요.

나의 풀이 (java)

import java.util.Collections;
import java.util.PriorityQueue;

class Solution {
    public int[] solution(String[] operations) {
        int[] answer = new int[2];
        PriorityQueue<Integer> maxQue = new PriorityQueue(Collections.reverseOrder());
        PriorityQueue<Integer> minQue = new PriorityQueue();

        for (String str:operations) {
            String[] operation = str.split(" ");
             if(operation[0].equals("I")) { // insert
                 maxQue.add(Integer.parseInt(operation[1]));
                 minQue.add(Integer.parseInt(operation[1]));
             }else if (operation[0].equals("D")){ // delete
                 if(maxQue.size()==0) continue;

                 if("1".equals(operation[1])){  // 최대값 삭제 및 동기화
                     minQue.remove(maxQue.remove());
                 }else if("-1".equals(operation[1])){ // 최소값 삭제 및 동기화
                     maxQue.remove(minQue.remove());
                 }
             }
        }
        answer[0] = maxQue.size()>0 ? maxQue.remove():0;
        answer[1] = minQue.size()>0 ? minQue.remove():0;
        return answer;
    }
}

풀이 방법

• (정렬된) 우선순위 큐를 2개 사용해서, 최소/최대값 관리
• 2개의 큐의 동기화 (remove를 이용)

다른사람의 풀이 (java)

import java.util.Collections;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
class Solution {
    public int[] solution(String[] arguments) {
        MidV q = new MidV();

        for(int i = 0; i < arguments.length; i++){
            String[] commend = arguments[i].split(" ");

            int v = Integer.parseInt(commend[1]);
            if(commend[0].equals("I")){
                q.push(v);
            }else{
                switch (v){
                    case 1 : q.removeMax();
                    break;
                    case -1: q.removeMin();
                    break;
                }
            }
        }


        int[] aw = new int[]{q.getMaxValue(),q.getMinValue()};

        return aw;
    }
}

class MidV{
    private PriorityQueue<Integer> leftHeap;
    private PriorityQueue<Integer> rightHeap;

    public MidV(){
        leftHeap = new PriorityQueue<>(10,Collections.reverseOrder());//최대값;
        rightHeap = new PriorityQueue<>();//최소값
    }


    public void push(int v){
        leftHeap.add(v);
    }

    public void removeMax(){

        while(!rightHeap.isEmpty()){
            leftHeap.add(rightHeap.poll());
        }

        leftHeap.poll();
    }

    public void removeMin(){

        while(!leftHeap.isEmpty()){
            rightHeap.add(leftHeap.poll());
        }

        rightHeap.poll();
    }

    public int getMaxValue(){

        if(leftHeap.size() == 0 && rightHeap.size() == 0)
            return 0;

        while(!rightHeap.isEmpty()){
            leftHeap.add(rightHeap.poll());
        }

        return leftHeap.peek();
    }

    public int getMinValue(){

        if(leftHeap.size() == 0 && rightHeap.size() == 0)
            return 0;

        while(!leftHeap.isEmpty()){
            rightHeap.add(leftHeap.poll());
        }

        return rightHeap.peek();
    }

}

느낀점

• (우선순위) 큐의 동작원리는 잘 알고 가자!
  • 노드 추가/삭제: add/remove

문제 설명

스트리밍 사이트에서 장르 별로 가장 많이 재생된 노래를 두 개씩 모아 베스트 앨범을 출시하려 합니다. 노래는 고유 번호로 구분하며, 노래를 수록하는 기준은 다음과 같습니다.

속한 노래가 많이 재생된 장르를 먼저 수록합니다.
장르 내에서 많이 재생된 노래를 먼저 수록합니다.
장르 내에서 재생 횟수가 같은 노래 중에서는 고유 번호가 낮은 노래를 먼저 수록합니다.
노래의 장르를 나타내는 문자열 배열 genres와 노래별 재생 횟수를 나타내는 정수 배열 plays가 주어질 때, 베스트 앨범에 들어갈 노래의 고유 번호를 순서대로 return 하도록 solution 함수를 완성하세요.

나의 풀이 (java)

import java.util.*;

class Solution {
    public int[] solution(String[] genres, int[] plays) {
        ArrayList<Integer> result =  new ArrayList();
        // map에 넣기 (장르+재생, 장르별 재생수용)
        Map playCountMap = new HashMap<>();
        for (int i = 0; i < genres.length; i++) {
            playCountMap.put(genres[i], (int)(playCountMap.get(genres[i])==null ? 0:playCountMap.get(genres[i]))+plays[i]);
        }

        // 정렬(장르별 재생수 합산)
        List<Map.Entry<String,Integer>> entryList = new ArrayList<>(playCountMap.entrySet());
        Collections.sort(entryList, (o1, o2) -> o2.getValue().compareTo(o1.getValue()));


        // 장르별 최대 2곡씩 선택
        for (Map.Entry<String, Integer> song : entryList) {
            int first = 0;
            int firstIndex = 0;
            int second = 0;
            int secondIndex = 0;

            for (int i = 0; i < genres.length; i++) {
                if(genres[i].equals(song.getKey())){
                    if(plays[i] > first){
                        second = first;
                        secondIndex = firstIndex;
                        first = plays[i];
                        firstIndex = i;
                    } else if(plays[i] > second){
                        second = plays[i];
                        secondIndex = i;
                    }
                }
            }
            result.add(firstIndex);
            if(second>0) result.add(secondIndex);
        }

        // arrList->arr
        return result.stream().mapToInt(Integer::intValue).toArray();
    }
}

풀이 방법

• HashMap을 사용하여 중복 제거 or 키-값별 카운트 가능

다른사람의 풀이 (java)

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Solution {
  public class Music implements Comparable<Music>{

    private int played;
    private int id;
    private String genre;

    public Music(String genre, int played, int id) {
      this.genre = genre; 
      this.played = played;
      this.id = id;
    }

    @Override
    public int compareTo(Music other) {
      if(this.played == other.played) return this.id - other.id;
      return other.played - this.played;
    }

    public String getGenre() {return genre;}
  }

  public int[] solution(String[] genres, int[] plays) {
    return IntStream.range(0, genres.length)
    .mapToObj(i -> new Music(genres[i], plays[i], i))
    .collect(Collectors.groupingBy(Music::getGenre))
    .entrySet().stream()
    .sorted((a, b) -> sum(b.getValue()) - sum(a.getValue()))
    .flatMap(x->x.getValue().stream().sorted().limit(2))
    .mapToInt(x->x.id).toArray();
  }

  private int sum(List<Music> value) {
    int answer = 0;
    for (Music music : value) {
      answer+=music.played;
    }
    return answer;
  }
}

Godd Idea : 다른사람 : class 나누고, Stream 활용

느낀점

• Comparator 대신 lamda사용
• arrayList<Integer> → array<int>
  => result.stream().mapToInt(Integer::intValue).toArray();

문제 설명

매운 것을 좋아하는 Leo는 모든 음식의 스코빌 지수를 K 이상으로 만들고 싶습니다. 모든 음식의 스코빌 지수를 K 이상으로 만들기 위해 Leo는 스코빌 지수가 가장 낮은 두 개의 음식을 아래와 같이 특별한 방법으로 섞어 새로운 음식을 만듭니다.

섞은 음식의 스코빌 지수 = 가장 맵지 않은 음식의 스코빌 지수 + (두 번째로 맵지 않은 음식의 스코빌 지수 * 2)

나의 풀이 (java)

import java.util.PriorityQueue;
class Solution {
    public int solution(int[] scoville, int K) {
        int answer = 0;
        // 우선순위큐(힙)에 넣어 정렬
        PriorityQueue<Integer> kScoville = new PriorityQueue();
        for (int scovilleIndex : scoville) {
            kScoville.offer(scovilleIndex);
        }

        while(kScoville.peek() < K){
            // 스코빌 섞기
            if(kScoville.size()==1) return -1;
            answer++;
            kScoville.add(kScoville.poll() + (kScoville.poll() * 2));
        }

        return answer;
    }
}

풀이 방법

• 특정 작업마다 정렬을 하면 비효율적 → 이럴때 힙(우선순위 큐)을 사용하면, 효율적으로 처리 가능
• 예외처리 (스코빌 지수를 K 이상으로 만들 수 없는 경우)

다른사람의 풀이 (java)

대부분 비슷

다만, Class를 나눠서, 재사용 가능하도록 짠 코드들은 인상적.

느낀점

특정 작업마다 정렬을 해야할 때 힙(우선순위 큐)을 사용하면, 효율적으로 처리 가능

문제 설명

트럭 여러 대가 강을 가로지르는 일차선 다리를 정해진 순으로 건너려 합니다. 모든 트럭이 다리를 건너려면 최소 몇 초가 걸리는지 알아내야 합니다. 다리에는 트럭이 최대 bridge_length대 올라갈 수 있으며, 다리는 weight 이하까지의 무게를 견딜 수 있습니다. 단, 다리에 완전히 오르지 않은 트럭의 무게는 무시합니다.

예를 들어, 트럭 2대가 올라갈 수 있고 무게를 10kg까지 견디는 다리가 있습니다. 무게가 [7, 4, 5, 6]kg인 트럭이 순서대로 최단 시간 안에 다리를 건너려면 다음과 같이 건너야 합니다.

나의 풀이 (java)

import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public int solution(int bridge_length, int weight, int[] truck_weights) {
        int seconds = 0;
        int truckIndex = 0;
        int passingWeights = 0;
        Queue<Integer> passingTruck = new LinkedList<>();

        while(truck_weights.length > truckIndex){
            seconds++;

            // 건너가는 트럭이 있다면 앞에서 하나씩 제거
            if(passingTruck.size() == bridge_length){
                passingWeights -= passingTruck.poll();
            }

            if(weight >= passingWeights + truck_weights[truckIndex]){
                // 다리 하중이 괜찮다면, 한 대 더 건너가기
                passingTruck.add(truck_weights[truckIndex]);
                passingWeights += truck_weights[truckIndex];
                truckIndex++;
            }else{
                passingTruck.add(0);
                // 다라 하중이 꽉차면, 다리 위의 트럭만 1칸 건너가기
            }
        }
        return seconds+bridge_length;
    }
}

풀이 방법

• Queue의 기본 메소드 (poll,add)를 이용해 트럭을 이동시킨다 (다리 전 -> 다리 위, 다리 위 -> 다리 후)
• 적절한 조건 처리 (다리 하중)

다른사람의 풀이 (java)

mport java.util.*;

class Solution {
    class Truck {
        int weight;
        int move;

        public Truck(int weight) {
            this.weight = weight;
            this.move = 1;
        }

        public void moving() {
            move++;
        }
    }

    public int solution(int bridgeLength, int weight, int[] truckWeights) {
        Queue<Truck> waitQ = new LinkedList<>();
        Queue<Truck> moveQ = new LinkedList<>();

        for (int t : truckWeights) {
            waitQ.offer(new Truck(t));
        }

        int answer = 0;
        int curWeight = 0;

        while (!waitQ.isEmpty() || !moveQ.isEmpty()) {
            answer++;

            if (moveQ.isEmpty()) {
                Truck t = waitQ.poll();
                curWeight += t.weight;
                moveQ.offer(t);
                continue;
            }

            for (Truck t : moveQ) {
                t.moving();
            }

            if (moveQ.peek().move > bridgeLength) {
                Truck t = moveQ.poll();
                curWeight -= t.weight;
            }

            if (!waitQ.isEmpty() && curWeight + waitQ.peek().weight <= weight) {
                Truck t = waitQ.poll();
                curWeight += t.weight;
                moveQ.offer(t);
            }
        }

        return answer;
    }
}

Godd Idea : Java의 OOP를 활용한 풀이. 객체를 만들어서 무게&이동을 관리한다는 접근이 좋은듯.

느낀점

이번 문제는 풀이가 다양하다. 직독직해 느낌의 내 풀이도 맘에 들지만!

다른 사람들의 풀이를 보는 재미가 있는 문제였다.

풀이 방법은 결국 비슷하지만, 구현하는 방식이 다 다르다!

객체를 만들어서 OOP로 접근하거나

Map으로 제거하는 방법도 좋았다.

문제 설명

일반적인 프린터는 인쇄 요청이 들어온 순서대로 인쇄합니다. 그렇기 때문에 중요한 문서가 나중에 인쇄될 수 있습니다. 이런 문제를 보완하기 위해 중요도가 높은 문서를 먼저 인쇄하는 프린터를 개발했습니다. 이 새롭게 개발한 프린터는 아래와 같은 방식으로 인쇄 작업을 수행합니다.

나의 풀이 (java)

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Queue;

class Solution {
    public int solution(int[] priorities, int location) {
        int answer = 0;
        // 필요한 변수 생성 (가장 높은 우선순위, 정렬된 우선순위, 우선순위 리스트)
        Integer biggestNum = 0;
        Queue<Integer> queue = new LinkedList<>();
        ArrayList<Integer> sortedPriorities = new ArrayList();
        for (int num: priorities) {
            queue.add(num);
            sortedPriorities.add(num);
        }
        sortedPriorities.sort(Collections.reverseOrder());

        while(true){
            // 큐에서 하나씩 빼거나, 빼서 맨 뒤로 보내거나
            biggestNum = sortedPriorities.get(answer);
            if (location == 0 && queue.peek() == biggestNum){
                answer++;
                break;
            } else if (queue.peek() < biggestNum){
                queue.add(queue.poll());
            } else {
                queue.poll();
                answer++;
            }

            // 내가 선택한 작업의 위치 관리하기
            if(location==0)
                location = queue.size()-1;
            else
                location--;
        }

        return answer;
    }
}

풀이 방법

• 큐를 이용해 원하는 로직을 구현하기
  • 대기 목록 우선 순위대로 수행 (큐에서 하나씩 빼거나, 빼서 맨 뒤로 보내거나)
  • 적절한 변수 생성 (location:선택한 작업 위치 관리, biggestNum:가장 높은 우선순위)

느낀점

로직 자체는 고민을 좀 하면 나올수 있으나

Array, List, Queue, int형이 섞였을때가 좀 헷갈리니 다시 정리

• Array 정렬 방법
      - 단순 정렬시 - Array.sort(arr)
• List 정렬 방법
      - 단순 정렬시 - Collections.sort(list)

// 둘 다 같음
sortedPriorities.sort(Collections.reverseOrder());
Collections.sort(sortedPriorities, Collections.reverseOrder());

문제 설명

괄호가 바르게 짝지어졌다는 것은 '(' 문자로 열렸으면 반드시 짝지어서 ')' 문자로 닫혀야 한다는 뜻입니다. 예를 들어

"()()" 또는 "(())()" 는 올바른 괄호입니다.
")()(" 또는 "(()(" 는 올바르지 않은 괄호입니다.
'(' 또는 ')' 로만 이루어진 문자열 s가 주어졌을 때, 문자열 s가 올바른 괄호이면 true를 return 하고, 올바르지 않은 괄호이면 false를 return 하는 solution 함수를 완성해 주세요.

나의 풀이 (java)

import java.util.Stack;

class Solution {

    public static void main(String[] args) {
        String str = "()()";
        boolean result = solution(str);
        System.out.println("### Result : " + result);
    }

    static boolean solution(String s) {
				boolean answer = false;
        Stack<Integer> criteria = new Stack<>();

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == '('){
                criteria.push(0);
            }else if (c == ')'){
                if (criteria.empty()) return false;
                criteria.pop();
            }
        }

        // split의 경우 효율성 검사에서 떨어짐
//        if (s.length()==0) return false;
//        String[] strArr = s.split("");
//        for (String str:strArr) {
//            if (str.equals("(")){
//                criteria.push(0);
//            }else if (str.equals(")")){
//                if (criteria.empty()) return false;
//                criteria.pop();
//            }
//        }

        if (criteria.empty()) answer = true;
        return answer;
    }
}

풀이 방법

• 간단한 Stack 사용 pop,push 사용법
• 문자열 for문을 사용법

다른사람의 풀이 (java)

Godd Idea :

느낀점

• 문자 for문 사용시, split(””)대신 charAt()으로 사용 (char은 ‘’로 문자열 비교)
  • split으로 문자열 반복문을 사용 할 경우, 효율성에서 통과하지 못하고, 자바 버전에 따라 문제가 생기기도 하니, charAt()을 사용하자!

문제 설명

당신은 폰켓몬을 잡기 위한 오랜 여행 끝에, 홍 박사님의 연구실에 도착했습니다. 홍 박사님은 당신에게 자신의 연구실에 있는 총 N 마리의 폰켓몬 중에서 N/2마리를 가져가도 좋다고 했습니다.
홍 박사님 연구실의 폰켓몬은 종류에 따라 번호를 붙여 구분합니다. 따라서 같은 종류의 폰켓몬은 같은 번호를 가지고 있습니다. 예를 들어 연구실에 총 4마리의 폰켓몬이 있고, 각 폰켓몬의 종류 번호가 [3번, 1번, 2번, 3번]이라면 이는 3번 폰켓몬 두 마리, 1번 폰켓몬 한 마리, 2번 폰켓몬 한 마리가 있음을 나타냅니다. 이때, 4마리의 폰켓몬 중 2마리를 고르는 방법은 다음과 같이 6가지가 있습니다.

나의 풀이 (java)

import java.util.HashSet;
class Solution {
    public int solution(int[] nums) {
        HashSet<Integer> tempSet = new HashSet<>();
        for(int i =0; i<nums.length;i++) {
            tempSet.add(nums[i]);
        }

        // map 크기 중 arr/2 크기 만큼 해서 최댓값 구하기
        int kindCount = tempSet.size();
        int selectCount = nums.length/2;
        return Math.min(kindCount, selectCount);
    }
}

풀이 방법 = 다른사람의 풀이 (java)

Godd Idea :

• HashSet 를 사용한 중복 제거 (HashSet = Array List와 비슷하지만 중복 제외,성능도 더 좋음)

느낀점

HashMap만 썼는데,
이런 경우에는 굳이 Map이 아닌 Set으로 처리 가능하다는 것과 쓰는 법을 배웠다