H-Index

📑 문1) H-Index는 과학자의 생산성과 영향력을 나타내는 지표입니다. 어느 과학자의 H-Index를 나타내는 값인 h를 구하려고 합니다. 위키백과1에 따르면, H-Index는 다음과 같이 구합니다.

어떤 과학자가 발표한 논문 n편 중, h번 이상 인용된 논문이 h편 이상이고 나머지 논문이 h번 이하 인용되었다면 h의 최댓값이 이 과학자의 H-Index입니다.

어떤 과학자가 발표한 논문의 인용 횟수를 담은 배열 citations가 매개변수로 주어질 때, 이 과학자의 H-Index를 return 하도록 solution 함수를 작성해주세요.

---

제한사항

• 과학자가 발표한 논문의 수는 1편 이상 1,000편 이하입니다.
• 논문별 인용 횟수는 0회 이상 10,000회 이하입니다.

---

입출력 예

citations	return
[3,0,6,1,5]	3

---

입출력 예 설명

이 과학자가 발표한 논문의 수는 5편이고, 그중 3편의 논문은 3회 이상 인용되었습니다. 그리고 나머지 2편의 논문은 3회 이하 인용되었기 때문에 이 과학자의 H-Index는 3입니다.

---

나의 풀이

package programmers;

import java.util.Arrays;

public class Citations {
	
	
	public static int solution(int[] citations) {
        
        
        Arrays.sort(citations);
        int length = citations.length;
       
        for(int i = 0; i < length; i++) {
        	int h = length - i;
        	if(citations[i] >= h) {
        		return h;
        	}
     
        }
     
        return 0;
       
    }
	
	
	public static void main(String[] args) {
		solution(new int[] {3,0,6,1,5});
	}

}

---

나의 생각

먼저, 매개변수로 주어진 citations을 오름차순으로 정렬을 한다.

문제에서 말하는 h-index는 n개의 논문 중 h번 이상 인용된 논문이 h편 이상이고 나머지 남은 논문이 h번 이하 인용되었다면 h의 최댓값이 h-index 이다.

for(int i = 0; i < length; i++) {
	int h = length - i;
    if(citations[i] >= h) {
    	return h;
    } 
}

i = 0, citations[i] = 0, h = 5
i = 1, citations[i] = 1, h = 4
i = 2, citations[i] = 3, h = 3
i = 3, citations[i] = 5, h = 2
i = 4, citations[i] = 6, h = 1

• int h = length - i : 여기서 h는 현재 인용 횟수가 h 이상인 논문의 최소 갯수를 나타낸다. 왜냐하면 citations 배열은 오름차순으로 정렬되었기 때문에, i 번째 논문의 인용 횟수가 h이상이라면,i 이후의 모든 논문들도 h 이상의 인용 횟수를 가지게 됨

• if(citations[i] >= h 이 조건은 현재 확인하는 논문의 인용 횟수가 h 이상인지 확인하고, 만약 h 이상이라면 h번 이상 인용된 논문이 h편 이상이 되므로, 현재의 h는 H-Index가 된다.

---

할인 행사

📑 문2) XYZ 마트는 일정한 금액을 지불하면 10일 동안 회원 자격을 부여합니다. XYZ 마트에서는 회원을 대상으로 매일 한 가지 제품을 할인하는 행사를 합니다. 할인하는 제품은 하루에 하나씩만 구매할 수 있습니다. 알뜰한 정현이는 자신이 원하는 제품과 수량이 할인하는 날짜와 10일 연속으로 일치할 경우에 맞춰서 회원가입을 하려 합니다.

예를 들어, 정현이가 원하는 제품이 바나나 3개, 사과 2개, 쌀 2개, 돼지고기 2개, 냄비 1개이며, XYZ 마트에서 15일간 회원을 대상으로 할인하는 제품이 날짜 순서대로 치킨, 사과, 사과, 바나나, 쌀, 사과, 돼지고기, 바나나, 돼지고기, 쌀, 냄비, 바나나, 사과, 바나나인 경우에 대해 알아봅시다. 첫째 날부터 열흘 간에는 냄비가 할인하지 않기 때문에 첫째 날에는 회원가입을 하지 않습니다. 둘째 날부터 열흘 간에는 바나나를 원하는 만큼 할인구매할 수 없기 때문에 둘째 날에도 회원가입을 하지 않습니다. 셋째 날, 넷째 날, 다섯째 날부터 각각 열흘은 원하는 제품과 수량이 일치하기 때문에 셋 중 하루에 회원가입을 하려 합니다.

정현이가 원하는 제품을 나타내는 문자열 배열 want와 정현이가 원하는 제품의 수량을 나타내는 정수 배열 number, XYZ 마트에서 할인하는 제품을 나타내는 문자열 배열 discount가 주어졌을 때, 회원등록시 정현이가 원하는 제품을 모두 할인 받을 수 있는 회원등록 날짜의 총 일수를 return 하는 solution 함수를 완성하시오. 가능한 날이 없으면 0을 return 합니다.

---

제한사항

• 1 ≤ want의 길이 = number의 길이 ≤ 10
  • 1 ≤ number의 원소 ≤ 10
  • number[i]는 want[i]의 수량을 의미하며, number의 원소의 합은 10입니다.
• 10 ≤ discount의 길이 ≤ 100,000
• want와 discount의 원소들은 알파벳 소문자로 이루어진 문자열입니다.
  • 1 ≤ want의 원소의 길이, discount의 원소의 길이 ≤ 12

---

입출력 예

want	number	discount	result
["banana", "apple", "rice", "pork", "pot"]	[3,2,2,2,1]	[["chicken", "apple", "apple", "banana", "rice", "apple", "pork", "banana", "pork", "rice", "pot", "banana", "apple", "banana"]]	3
["apple"]	[10]	[["banana", "banana", "banana", "banana", "banana", "banana", "banana", "banana", "banana", "banana"]]	0

---

나의 풀이

package programmers;

import java.util.HashMap;

public class DiscountEvent {
	
	
	public static int solution(String[] want, int[] number, String[] discount) {
        int answer = 0;
        HashMap<String, Integer> wantMap = new HashMap<>();
        
        for(int i = 0; i < want.length; i++) {
        	wantMap.put(want[i], number[i]);
        }
        
        
        int totalDiscountDay = 0;
        
        for(int a : number) {
        	totalDiscountDay += a;
        }
        
        
        for(int i = 0; i <= discount.length - totalDiscountDay; i++) {
            HashMap<String, Integer> tempMap = new HashMap<>(wantMap);
            for(int j = i; j < i + totalDiscountDay; j++) {
                if(tempMap.containsKey(discount[j])) {
                    tempMap.put(discount[j], tempMap.get(discount[j]) - 1);
                    if(tempMap.get(discount[j]) == 0) {
                        tempMap.remove(discount[j]);
                    }
                }
            }
            
            if(tempMap.isEmpty()) {
                answer++;
            }
        }
        
        
        
      
        return answer;
    }
	
	public static void main(String[] args) {
		
		String[] want = {"banana", "apple", "rice", "pork", "pot"};
		int[] number = {3, 2, 2, 2, 1};
		String[] discount = {"chicken", "apple", "apple", "banana", "rice", 
				"apple", "pork", "banana", "pork", "rice", "pot", "banana", "apple", "banana"};
		
		solution(want, number, discount);
	}

}

---

나의 생각

을 보면 알 수 있듯이, 매개변수로 주어지는 want,number를 key, value에 저장해야한다. 이를 위해 map을 사용하였으며 map에는 다음과 같이 저장된다.

마트에서 할인 하는 행사 품목을 담은 매개변수 discount는 항상 want 배열보다 크고, number 안에 든 {3,2,2,2,1} 필요한 갯수의 총 합을 저장할 totalDiscountDay에 저장한다.

만약, discount [0] ~ discount [9] (총 10개) 항목이 연속으로 갯수를 체크하여 정현이가 원하는 want 항목의 갯수가 모두 포함되는지 확인하는 문제이다.

즉,

discount [0] ~ discount [9]
discount [1] ~ discount [10]
discount [2] ~ discount [11]
discount [3] ~ discount [12]
discount [4] ~ discount [13]

순서로 연속적인 배열의 값을 확인해야한다. 핵심 로직은 다음과 같다.

for(int i = 0; i <= discount.length - totalDiscountDay; i++) {
	HashMap<String, Integer> tempMap = new HashMap<>(wantMap);
    for(int j = i; j < i + totalDiscountDay; j++) {
    	if(tempMap.containsKey(discount[j])) {
        	tempMap.put(discount[j], tempMap.get(discount[j]) - 1);
            if(tempMap.get(discount[j]) == 0) {
            	tempMap.remove(discount[j]);
            }
         }
    }
            
    if(tempMap.isEmpty()) {
    	answer++;
    }
 }

현재 map에 저장된 항목은 다음과 같다.

for(int i = 0; i <= 14 - 10; i++)

• 정현이가 원하는 want의 항목의 갯수가 5개 이기때문에 바깥 for은 위와 같이 동작한다.

HashMap<String, Integer> tempMap = new HashMap<>(wantMap)

• 여기서 tempMap이 필요한 이유는 반복을 한번 돌때마다 그 안에 있는 값들이 초기화가 이루어져야하기 때문이다.

for(int j = i; j < i + totalDiscountDay; j++)

• 내가 생각하는 핵심 로직인데, 다음과 같이 동작한다. 동작 순서를 보면 이해될것이다.

j = 0 ; j < 0 + 10; j++
j = 1 ; j < 1 + 10; j++
j = 2 ; j < 2 + 10; j++
j = 3 ; j < 3 + 10; j++

discount [0] ~ discount [9]
discount [1] ~ discount [10]
discount [2] ~ discount [11]
discount [3] ~ discount [12]
discount [4] ~ discount [13]

if(tempMap.containsKey(discount[j])) {
	tempMap.put(discount[j], tempMap.get(discount[j]) - 1);
    if(tempMap.get(discount[j]) == 0) {
    	tempMap.remove(discount[j]);
    }
}

해당 로직은 tempMap에 discount[j] 값과 일치하는 값이 있으면 value값을 1개씩 빼주는 로직이다. 즉, tempMap 의 모든 value값이 0이되면 , temp.remove() 메서드를 활용하여 tempMap을 빈 상태로 만들어 버린다. 즉, discount의 모든 항목이 want에 포함되고, 갯수까지 모두 일치하면 answer++를 통해 최종적으로 return한다.

---

행렬의 곱셈

📑 문3) 2차원 행렬 arr1과 arr2를 입력받아, arr1에 arr2를 곱한 결과를 반환하는 함수, solution을 완성해주세요.

---

제한조건

• 행렬 arr1, arr2의 행과 열의 길이는 2 이상 100 이하입니다.
• 행렬 arr1, arr2의 원소는 -10 이상 20 이하인 자연수입니다.
• 곱할 수 있는 배열만 주어집니다.

---

입출력 예

arr1	arr2	return
[[1, 4], [3, 2], [4, 1]]	[[3, 3], [3, 3]]	[[15, 15], [15, 15], [15, 15]]
[[2, 3, 2], [4, 2, 4], [3, 1, 4]]	[[5, 4, 3], [2, 4, 1], [3, 1, 1]]	[[22, 22, 11], [36, 28, 18], [29, 20, 14]]

---

나의 풀이

package programmers;

public class MatrixProduct {
	
	public static int[][] solution(int[][] arr1, int[][] arr2) {
		
		
		int row1 = arr1.length;
		int col1 = arr1[0].length;
		int row2 = arr2.length;
		int col2 = arr2[0].length;
		
		int[][] answer = new int[row1][col2];
		
		
		for(int i = 0; i < row1; i++) {
			for(int j = 0; j < col2; j++) {
				int sum = 0;
				
				for(int k = 0; k < col1; k++) {
					sum += arr1[i][k] * arr2[k][j];
				}
				
				answer[i][j] = sum;
			}
		}
		
		
       
        return answer;
    }
	
	
	public static void main(String[] args) {
		
		int[][] arr1 = new int[][] {{1,4},{3,2},{4,1}};
		
		int[][] arr2 = new int[][] {{3,3},{3,3}};
		
		
		
		solution(arr1, arr2);
	}
	
	
	

}

---

나의 생각

1. 행렬의 곱셈에서는 arr1의 열 수 (col1)와 arr2 의 행수 (row2)가 같아야한다.

2. 결과 행렬의 크기 결정

• answer의 크기는 arr1의 행수(row1) * arr2의 열 수(col2)로 결정

핵심 로직

for(int i = 0; i < row1; i++) {
    for(int j = 0; j < col2; j++) {
        int sum = 0;
        for(int k = 0; k < col1; k++) {
            sum += arr1[i][k] * arr2[k][j];
        }
        answer[i][j] = sum;
    }
}

sum += arr1[i][k] * arr2[k][j]

• arr1의 열수 k 와 arr2의 행수 k가 같아야 한다는 조건을 만족

---

캐시

📑 문4) 지도개발팀에서 근무하는 제이지는 지도에서 도시 이름을 검색하면 해당 도시와 관련된 맛집 게시물들을 데이터베이스에서 읽어 보여주는 서비스를 개발하고 있다.
이 프로그램의 테스팅 업무를 담당하고 있는 어피치는 서비스를 오픈하기 전 각 로직에 대한 성능 측정을 수행하였는데, 제이지가 작성한 부분 중 데이터베이스에서 게시물을 가져오는 부분의 실행시간이 너무 오래 걸린다는 것을 알게 되었다.
어피치는 제이지에게 해당 로직을 개선하라고 닦달하기 시작하였고, 제이지는 DB 캐시를 적용하여 성능 개선을 시도하고 있지만 캐시 크기를 얼마로 해야 효율적인지 몰라 난감한 상황이다.

어피치에게 시달리는 제이지를 도와, DB 캐시를 적용할 때 캐시 크기에 따른 실행시간 측정 프로그램을 작성하시오.

---

입력 형식

• 캐시 크기(cacheSize)와 도시이름 배열(cities)을 입력받는다.
• cacheSize는 정수이며, 범위는 0 ≦ cacheSize ≦ 30 이다.
• cities는 도시 이름으로 이뤄진 문자열 배열로, 최대 도시 수는 100,000개이다.
• 각 도시 이름은 공백, 숫자, 특수문자 등이 없는 영문자로 구성되며, 대소문자 구분을 하지 않는다. 도시 이름은 최대 20자로 이루어져 있다.

---

출력 형식

• 입력된 도시이름 배열을 순서대로 처리할 때, "총 실행시간"을 출력한다.

---

조건

• 캐시 교체 알고리즘은 LRU(Least Recently Used)를 사용한다.
• cache hit일 경우 실행시간은 1이다.
• cache miss일 경우 실행시간은 5이다.

---

입출력 예

캐시크기(cacheSize)	도시이름(cities)	실행시간
3	["Jeju", "Pangyo", "Seoul", "NewYork", "LA", "Jeju", "Pangyo", "Seoul", "NewYork", "LA"]	50
3	["Jeju", "Pangyo", "Seoul", "Jeju", "Pangyo", "Seoul", "Jeju", "Pangyo", "Seoul"]	21
2	["Jeju", "Pangyo", "Seoul", "NewYork", "LA", "SanFrancisco", "Seoul", "Rome", "Paris", "Jeju", "NewYork", "Rome"]	60
5	["Jeju", "Pangyo", "Seoul", "NewYork", "LA", "SanFrancisco", "Seoul", "Rome", "Paris", "Jeju", "NewYork", "Rome"]	52
2	["Jeju", "Pangyo", "NewYork", "newyork"]	16
0	["Jeju", "Pangyo", "Seoul", "NewYork", "LA"]	25

---

나의 풀이

package programmers;

import java.util.LinkedList;

public class Cache {
	
	public static int solution(int cacheSize, String[] cities) {
       
        
        LinkedList<String> cityList = new LinkedList<>();
        
        int runTime = 0;
        
        for(String city : cities) {
        	
        	city = city.toLowerCase();
        	
        	if(cityList.contains(city)) {
        		cityList.remove(city);
        		runTime += 1;
        	}else {
        		if(cityList.size() == cacheSize && cacheSize != 0) {
        			cityList.removeFirst();
        		}
        		runTime += 5;
        	}
        	
        	if(cacheSize != 0) {
        		cityList.addLast(city);
        	}
        	
        }
        
        
       
        return runTime;
    }
	
	
	public static void main(String[] args) {
		
		String[] cities = {"Jeju", "Pangyo", "Seoul", "Jeju", "Pangyo", "Seoul", "Jeju", "Pangyo", "Seoul"};
		solution(3, cities);
	}

}

---

나의 생각

LRU(Least Recently Used)

• 페이지 교체 알고리즘 중 하나로 캐시에서 가장 오랫동안 사용되지 않은 항목을 식별하여 새로운 데이터로 대체할 때 사용

• 캐시에 데이터를 추가할 때마다, 해당 데이터에 대한 최근 사용 시점을 기록

• 캐시가 가득 찼을 때 새로운 데이터를 추가하려고 하면, 가장 오래 전에 사용된 데이터 (즉, 가장 최근에 사용되지 않은 데이터)를 캐시에서 제거하고 새로운 데이터를 삽입

예제 1번 예시

cacheSize = 3
cities = ["Jeju", "Pangyo", "Seoul", "NewYork", "LA", "Jeju", "Pangyo", "Seoul", "NewYork", "LA"]

시작할 때, 캐시는 비어있음

1. Jeju

• cache miss(캐시에 Jeju가 없음)
• [Jeju] (Jeju 캐시에 추가됨)
• 실행시간 : 5

2. Pangyo

• cache miss(캐시에 Pangyo가 없음)
• [Jeju,Pangyo] (Pangyo 캐시에 추가됨)
• 실행시간 : 5

3. Seoul

• cache miss(캐시에 Seoul이 없음)
• [Jeju,Pangyo,Seoul] (Seoul 캐시에 추가됨)
• 실행시간 : 5

이 시점에서는 캐시가 꽉 차 있음, 따라서 새로운 도시를 캐시에 추가하기 위해서는 가장 오래 전에 사용된 도시를 제거해야함

1. NewYork

• cache miss(캐시에 NewYork이 없음)
• 가장 오래 전에 사용된 Jeju를 제거
• [Pangyo, Seoul, NewYork] (NewYork 캐시에 추가됨)
• 실행시간 : 5

이제 Pangyo가 가장 오래 전에 사용된 도시

1. LA

• cache miss(캐시에 LA가 없음)
• 가장 오래 전에 사용된 Pangyo를 제거
• [Seoul,NewYork,LA] (LA 캐시에 추가됨)
• 실행시간 : 5

계속 진행하면서 각 단계별로 실행 시간을 누적하면 최종 실행 시간은 50이 됨

주요 로직을 살펴보자

핵심 로직은 다음과 같다.

LinkedList<String> cityList = new LinkedList<>();
int runTime = 0;
        
for(String city : cities) {
        	
	city = city.toLowerCase();
        	
    if(cityList.contains(city)) {
        cityList.remove(city);
       	runTime += 1;
    }else {
    	if(cityList.size() == cacheSize && cacheSize != 0) {
        	cityList.removeFirst();
        }
    	runTime += 5;
    }
        	
    if(cacheSize != 0) {
   		cityList.addLast(city);
    }
        	
 }		

매개변수로 주어지는 int cacheSize, String[] cities 를 바탕으로 List의 maxSize와 나열된 cities를 담을 List를 선언하는데, 캐시는 순서가 중요하기때문에 순서까지 저장하는 LinkedList를 사용. 그리고 전체 cities를 순회하는데, 순회할때의 모든 city = city.toLowCase()로 소문자로 변환(대소문자 구별 없음)한다. 처음 3개의 도시는 cityList 에 포함돼있지 않기때문에 runTime +=5 및 if(cacheSize != 0){cityList.addLast(city)} 에서 동작하며 cacheSize와 cityList의 size가 같아지는 순간부터 cityList의 첫번째 Index를 제거, 다음 city를 맨끝에 추가하는 방식이다. 만약, cityList에 존재하는 도시가 다시 등장하면, cityList에서 해당 도시의 이름을 제거하고, runTime +=1; 이후, 다시 그 도시를 cityList 맨 끝에 추가한다.

---

의상

📑 문5) 코니는 매일 다른 옷을 조합하여 입는것을 좋아합니다.

예를 들어 코니가 가진 옷이 아래와 같고, 오늘 코니가 동그란 안경, 긴 코트, 파란색 티셔츠를 입었다면 다음날은 청바지를 추가로 입거나 동그란 안경 대신 검정 선글라스를 착용하거나 해야합니다.

종류	이름
얼굴	동그란 안경, 검정 선글라스
상의	파란색 티셔츠
하의	청바지
겉옷	긴 코트

• 코니는 각 종류별로 최대 1가지 의상만 착용할 수 있습니다. 예를 들어 위 예시의 경우 동그란 안경과 검정 선글라스를 동시에 착용할 수는 없습니다.
• 착용한 의상의 일부가 겹치더라도, 다른 의상이 겹치지 않거나, 혹은 의상을 추가로 더 착용한 경우에는 서로 다른 방법으로 옷을 착용한 것으로 계산합니다.
• 코니는 하루에 최소 한 개의 의상은 입습니다.

코니가 가진 의상들이 담긴 2차원 배열 clothes가 주어질 때 서로 다른 옷의 조합의 수를 return 하도록 solution 함수를 작성해주세요.

---

제한사항

• clothes의 각 행은 [의상의 이름, 의상의 종류]로 이루어져 있습니다.
• 코니가 가진 의상의 수는 1개 이상 30개 이하입니다.
• 같은 이름을 가진 의상은 존재하지 않습니다.
• clothes의 모든 원소는 문자열로 이루어져 있습니다.
• 모든 문자열의 길이는 1 이상 20 이하인 자연수이고 알파벳 소문자 또는 '_' 로만 이루어져 있습니다.

---

입출력 예

clothes	return
[["yellow_hat", "headgear"], ["blue_sunglasses", "eyewear"], ["green_turban", "headgear"]]	5
[["crow_mask", "face"], ["blue_sunglasses", "face"], ["smoky_makeup", "face"]]	3

---

입출력 예 설명

예제 #1

• headgear에 해당하는 의상이 yellow_hat, green_turban이고 eyewear에 해당하는 의상이 blue_sunglasses이므로 아래와 같이 5개의 조합이 가능

1. yellow_hat
2. blue_sunglasses
3. green_turban
4. yellow_hat + blue_sunglasses
5. green_turban + blue_sunglasses

예제 #2

• face에 해당하는 의상이 crow_mask, blue_sunglasses, smoky_makeup이므로 아래와 같이 3개의 조합이 가능

1. crow_mask
2. blue_sunglasses
3. smoky_makeup

---

나의 풀이

package programmers;

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

public class Clothes {
	
	 public static int solution(String[][] clothes) {
	        int answer = 1;
	        HashMap<String, ArrayList<String>> clothesMap = new HashMap<>();
	        
	        
	        
	        for(String[] cloth : clothes) {
	        	
	        	String clothName = cloth[0];
	        	String clothType = cloth[1];
	        	
	        	if(!clothesMap.containsKey(clothType)) {
	        		clothesMap.put(clothType, new ArrayList<>());
	        	}
	        	
	        	clothesMap.get(clothType).add(clothName);
	        	
	        }
	        
	       
	        for(ArrayList<String> value : clothesMap.values()) {
	        	answer *= (value.size() + 1);
	        }
	        
	        return answer - 1;
	 }
	 
	 public static void main(String[] args) {
		 
		String[][] clothes = {{"crow_mask", "face"}, {"blue_sunglasses", "face"}, {"smoky_makeup", "face"}};
		solution(clothes);
	}

}

---

나의 생각

의상의 종류와 의상의 이름을 Map 형식으로 의상의 종류는 key, 의상의 이름들을 value로 들어가는데, value의 형식은 ArrayList로 valuer값이 하나가 될수도, 여러개가 될 수 있도록 구성하였다.

for(String[] cloth : clothes) {
	        	
	String clothName = cloth[0];
	String clothType = cloth[1];
	        	
	if(!clothesMap.containsKey(clothType)) {
		clothesMap.put(clothType, new ArrayList<>());
	}
	        	
	clothesMap.get(clothType).add(clothName);
	        	
}

for문 내부에 지역변수로 선언하여 for문 반복을 진행하면서 그 값들이 변경되게끔 구성하였다.

clothesMap에 의상의 종류가 없으면 clothType과, new ArrayList<>()(새로운 ArrayList)를 생성하였다. 그리고 해당하는 key값이 존재한다면, key에 해당하는 value값을 하나씩 추가해주는 방법을 사용

key, value로 Map을 구성한 모습

정제된 값을 바탕으로 조합을 구하는 방법은 다음과 같다.

• 의상을 선택하는 경우의 수를 구하기 위해선 각 의상 카테고리(type)별로 선택하지 않는 경우를 포함해서 경우의 수를 구하고, 모든 의상을 선택하지 않는 경우 1을 빼면된다.

• 각 의상 카테고리별로 선택하는 경우의 수는 해당 카테고리의 의상 개수+1(선택하지 않는 경우)

1. eyewear : blue_sunglasses(1가지) + 선택하지 않는 경우 = 1 + 1 = 2
2. headgear : yellow_hat, green_turban (2가지) + 선택하지 않는 경우 = 2 + 1 = 3

총 경우의 수는 각 카테고리별 경우의 수를 모두 곱한 후, 모든 의상을 선택하지 않는 경우 1을 뺀 것.

따라서 총 경우의 수는 2 * 3 -1 = 5

로직을 위 그림과 같이 구현하면 로직 설계대로 문제를 해결할 수 있음