Queue<Integer> queue = new LinkedList<>();

• BFS에 사용할 큐
• queue는 선입선출(FIFO)구조이므로, BFS에 적합
• 큐에 탐색할 노드를 저장 후, 하나씩 꺼내서 탐색

2. queue 시작노드 추가

queue.add(start);

3. 시작노드 방문 처리

visited[start] = true;

4. 큐가 비어있지않을 때까지 반복

while (!queue.isEmpty())

5. 큐에서 노드 꺼내기

📘 queue.poll

int node = queue.poll();

• 큐에서 노드 하나를 꺼내서 그 노드에 연결된 다른 노드 탐색하게됨
• queue.poll()은 노드를 꺼내면서 동시에 큐에서 제거

6. 모든 A 검사

for (int i = 0; i < n; i++)

• i는 현재 노드와 연결된 다른 노드들을 검사하기 위한 변수
• n은 총 검사할 모든 A의 개수

7. 연결 여부 및 방문 여부 확인

if(computers[node][i] == 1 && !visited[i])

8. 방문 처리

visited[i] = true;

9. 새로 탐색해야할 노드를 큐에 추가

queue.add(i);

• 현재 노드와 연결된 새로운 노드인 i를 탐색하기위해 큐에 추가

• DFS는 경로 찾기,탐색을 끝까지 진행하는 문제

  • 모든 경우의 수 찾기
  • 연결된 컴포넌트 탐색 등

• BFS는 보통 최단거리 문제, 레벨별 탐색 문제

  • 최단 경로
  • 레벨별 출력 등

📘 DFS

먼저 깊게 파고들어간 후, 더 이상 갈 곳이 없으면 다시 돌아오는 방식으로 탐색

✨ 특징

• 한 경로를 끝까지 탐색
• 현재 노드에서 자식노드로 계속 깊이 들어가다가 더이상 갈 곳이 없으면 되돌아와서 다른 경로 탐색
• 트리 or 그래프에서 한 뱡향으로 깊이 파고들면서 탐색

📘 BFS

넓게 탐색하는 방식, 한번에 모든 노드 탐색 -> 자식노드 탐색

현재 노드와 같은 깊이의 노드들 먼저 탐색 후, 아래로 내려가서 탐색

✨ 특징

• 현재 경로에서 한 단계씩 확장하면서 탐색
• 모든 노드 한번에 탐색 후, 자식 노드 탐색 방식
• 너비 우선(같은 레벨 노드 먼저)

n개의 음이 아닌 정수들이 있습니다. 이 정수들을 순서를 바꾸지 않고 적절히 더하거나 빼서 타겟 넘버를 만들려고 합니다. 예를 들어 [1, 1, 1, 1, 1]로 숫자 3을 만들려면 다음 다섯 방법을 쓸 수 있습니다.

-1+1+1+1+1 = 3 +1-1+1+1+1 = 3 +1+1-1+1+1 = 3 +1+1+1-1+1 = 3 +1+1+1+1-1 = 3

사용할 수 있는 숫자가 담긴 배열 numbers, 타겟 넘버 target이 매개변수로 주어질 때 숫자를 적절히 더하고 빼서 타겟 넘버를 만드는 방법의 수를 return 하도록 solution 함수를 작성해주세요.

입출력 예

📑 풀이

class Solution {
    public int answer = 0; // 타겟 넘버를 만드는 방법의 수

    public int solution(int[] numbers, int target) {
        dfs(numbers, 0 , 0 , target);
        return answer;
    }

    // 깊이 우선 탐색
    public void dfs(int[] numbers, int index, int currentSum, int target){
        if(index == numbers.length){
            if(currentSum == target){
                answer++;
            }
            return; // 종료
        }

        // 현재 숫자 더하기
        dfs(numbers, index+1, currentSum+numbers[index], target);
        // 현재 숫자 빼기
        dfs(numbers, index+1, currentSum-numbers[index], target);
    }
}

👀 문제 출처

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

속한 노래가 많이 재생된 장르를 먼저 수록합니다. 장르 내에서 많이 재생된 노래를 먼저 수록합니다. 장르 내에서 재생 횟수가 같은 노래 중에서는 고유 번호가 낮은 노래를 먼저 수록합니다.

노래의 장르를 나타내는 문자열 배열 genres와 노래별 재생 횟수를 나타내는 정수 배열 plays가 주어질 때, 베스트 앨범에 들어갈 노래의 고유 번호를 순서대로 return 하도록 solution 함수를 완성하세요

📑 풀이

import java.util.*;

class Solution {
    public int[] solution(String[] genres, int[] plays) {
        Map<String, Integer> genrePlayCount = new HashMap<>(); // 각 장르에 대한 재생횟수
        Map<String, List<int[]>> genreSongList = new HashMap<>(); 
        // 장르별 재생횟수와 인덱스 값 저장

        // HashMap에 장르별 재생 횟수 총합 계산
        for (int i = 0; i < genres.length; i++) {
            genrePlayCount.put(genres[i], genrePlayCount.getOrDefault(genres[i], 0) + plays[i]);

            // 각 장르에 해당하는 노래 정보 없으면 새로 만듦 [인덱스값, 재생횟수]
            if (!genreSongList.containsKey(genres[i])) {
                genreSongList.put(genres[i], new ArrayList<>());
            }
            // 장르와 인덱스 값(i), 재생횟수 저장
            genreSongList.get(genres[i]).add(new int[]{i, plays[i]}); 
        }

        // {"pop", "classic"} 형태로 장르 반환
        List<String> genreList = new ArrayList<>(genrePlayCount.keySet()); 

        // 장르별 총 재생 횟수를 기준으로 내림차순 정렬
        genreList.sort((g1, g2) -> genrePlayCount.get(g2) - genrePlayCount.get(g1));

        // 결과 저장 리스트 생성
        List<Integer> result = new ArrayList<>();

        // 각 장르별로 가장 많이 재생된 상위 2곡 추출
        for (String genre : genreList) { // genreList는 {"pop", "classic"}
            List<int[]> songs = genreSongList.get(genre);
            songs.sort((s1, s2) -> s2[1] - s1[1]); // 재생횟수를 기준으로 내림차순 정렬

            // 가장 많이 재생된 2곡만 선택
            int count = 0;
            for (int[] song : songs) {
                if (count >= 2) break;
                result.add(song[0]); // 인덱스만 저장
                count++;
            }
        }

        // 결과를 리스트에서 int[] 배열로 반환
        return result.stream().mapToInt(i -> i).toArray();
    }
}

장르와 노래 재생 횟수, 고유번호인 인덱스값 3가지가 필요하므로, 먼저

HashMap에 각 장르의 재생횟수 총합을 구하고, 또 다른 하나의 키 장르에 고유번호와 재생횟수 2개의 값을 갖는 HashMap을 만든다.

✨HashMap 자체는 정렬되지않으므로, Map을 리스트로 변환하는 작업이 필요하다. 정렬을 위해 리스트를 생성하여 키 값인 장르를 넣고, 그 키를 기준으로 장르별 재생횟수를 내림차순으로 정렬 후 저장한다. >> 노래가 많이 재생된 장르 구함

장르 내에서 많이 재생된 노래를 먼저 수록하기 위해,

새로 생성된 노래 리스트에 하나의 키 장르에 고유번호와 재생횟수 2개의 값이 저장된 genreSongList 맵을 이용하여 넣고 그 값들을 내림차순 후, 결과 리스트에 상위 2곡의 인덱스(고유번호)만 저장한다.

"pop" = [{0,200}.[3.150}..] >> 1개의 장르 키와 2개의 값 형태

리스트를 Int배열로 반환하기 위해, 결과 리스트를 스트림으로 바꾸고, 스트림의 각 요소를 int로 변환 후(Integer -> int), 배열로 변환한다. return result.stream().mapToInt(i -> i).toArray();

👀 문제 출처

데이터구조에서 데이터를 빠르게 저장하고 검색하는 방법

📚 HashMap 메소드

key와 value 2개의 값을 쌍으로 데이터 저장, 관리하는 자료 구조

❗❗ 정렬된 결과가 필요할 때, 해시테이블을 사용해서 데이터 저장 >> 삽입 순서는 유지 / 키나 값의 순서 보장X 따라서, 새로 리스트를 생성하여 정렬 후 저장한다.

1. 기본 메소드

• put(key, value)

  • key와 value를 HashMap에 추가
  • 이미 key가 존재하는 경우, 그 값을 덮어씀

• get(key)

  • key에 해당하는 값 반환
  • 존재하지 않으면 null 반환

• remove(key)

  • key에 해당하는 값 삭제
  • 삭제된 값은 반환됨

• size()

  • HashMap에 저장된 키-값 쌍의 수 반환 int size = map.size();

• containValue(value)

  • HashMap에 value 있으면, true 반환 boolean exists = map.containValue(10);

• isEmpty()

  • HashMap이 비어있으면 true / false boolean isEmpty = map.isEmpty(10);

• clear()

  • HashMap 모든 항목 삭제 map.clear()

  ---

  2. 조회 메소드

• keySet()

  • HashMap에 저장된 모든 key 반환하는 set 반환 Set<K> keys = map.keySet();

• values()

  • HashMap에 저장된 모든 value 반환하는 collection(객체들의 집합) 반환 Collection<V> values = map.values();

• entrySet()

  • HashMap에 저장된 모든 key-value 쌍 반환하는 Set<Map.Entry<k,V>>을
  • key와 value값 동시 처리 Set<Map,Entry<k,v>> entrySet = map.entrySet();

📚 HashSet 메소드

HashMap에서 value만 사용, key가 중복되지않은 특성을 가진 집합(Set) 자료구조

• add(c)

  • 요소 추가(중복X)

• contains(c)

  • 요소가 집합에 존재하는지 확인

• remove(c)

  • 요소를 집합에서 제거

• size()

  • 요소의 개수를 반환

• isEmpty()

  • 집합이 비었는지 확인

• clear()

  • 집합의 모든 요소 제거

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

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

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

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

📑 풀이 (HashMap 이용)

import java.util.*;

class Solution {
    public int solution(String[][] clothes) {
        int result = 1; // 곱셈을 위한 기본값 1

        // HashMap 생성
        Map<String,Integer> clothesCount = new HashMap();

        // HashMap에 clothes 배열의 의상 종류별 개수 저장
        for(int i=0;i<clothes.length;i++){
            String Category = clothes[i][1]; // 의상 종류 key
            clothesCount.put(Category, clothesCount.getOrDefault(Category,0)+1);
        }

        // 의상 조합 수 계산
        for(int c:clothesCount.values()){
            result *= c+1; // 각 의상종류 별 선택하지 않은 경우
        }

        // 아무것도 선택하지 않은 경우 제외
        result -= 1;

        return result;
    }
}

의상 이름은 필요하지 않으므로, 의상종류에 대한 개수만 구함.

예를 들어, 모자가 2개면 각 1개씩 선택하는 경우와 모자를 하나도 선택 안하는 경우,

2+1 = 3개

바지가 3개면, 각 1개씩 선택하는 경우 3개와, 바지 하나도 선택 안 하는 경우,

3+1 = 4개

두 의상 종류 조합하면,

3 * 4 = 12개

아무것도 선택하지 않는 경우 1개 제외

12 -1 = 11개

👀 문제 출처

• 문자열이 다른 문자열(전체) 안에 포함되어있는지 확인
• 반환값 : true / false

String str = "Hello, World";
boolean result = str.contains("World"); // true

📘 startsWith()

• 문자열이 특정 문자열로 시작하는지 확인
• 접두어 확인

String str = "Hello, World";
boolean result = str.startsWith("World"); // false

📘 차이점

• contains()는 문자열이 전체 문자열 어디에든 포함되어있는지 여부를 확인
• startsWith( )는 시작 부분을 비교

전화번호부에 적힌 전화번호 중, 한 번호가 다른 번호의 접두어인 경우가 있는지 확인하려 합니다. 전화번호가 다음과 같을 경우, 구조대 전화번호는 영석이의 전화번호의 접두사입니다.

구조대 : 119 박준영 : 97 674 223 지영석 : 11 9552 4421 전화번호부에 적힌 전화번호를 담은 배열 phone_book 이 solution 함수의 매개변수로 주어질 때, 어떤 번호가 다른 번호의 접두어인 경우가 있으면 false를 그렇지 않으면 true를 return 하도록 solution 함수를 작성해주세요.

📑 첫번째 풀이

import java.util.*;

class Solution {
    public boolean solution(String[] phone_book) {
        boolean answer = true;

        // 접두어 찾기
        for(int i=0;i<phone_book.length;i++){
            for(int j=0;j<phone_book.length;j++){
                if(i!=j && phone_book[j].startsWith(phone_book[i])){
                    answer = false; // 있으면
                    break;
                }
            }
            if(!answer) break;
        }

        return answer;
    }
}

모든 배열 값에 대해 for문으로 돌면서 startsWith 메소드로 phone_book[j]가 phone_book[i]로 시작하는지 비교했는데, 정확성은 맞지만, 효율성 테스트 시, 시간이 오래걸려 다시 풀어보았다(시간복잡도 O(n^2))

📑 두번째 풀이

import java.util.*;

class Solution {
    public boolean solution(String[] phone_book) {
        boolean answer = true;

        // 오름차순(사전순)으로 정렬
        Arrays.sort(phone_book);

        // 접두어 찾기
        for(int i=0;i<phone_book.length-1;i++){ // 마지막은 비교대상이 없으므로
            if(phone_book[i+1].startsWith(phone_book[i])){
                answer = false; // 있으면
                break;
            }
        }

        return answer;
    }
}

시간복잡도를 줄이기 위해, Arrays.sort()를 사용 > 시간복잡도 O(NlogN)

1. 전화번호 배열을 사전순으로 정렬
2. 앞 뒤 두개의 전화번호를 비교 > 접두어 확인함
3. 마지막 값은 비교대상이 없으므로 그 앞까지만 비교함

📘 startsWith 메소드

A.startsWith(B) > A가 B로 시작하는지 확인 하는 메소드(접두어 확인)

• 반환값 : true / false

👀 문제 출처

수많은 마라톤 선수들이 마라톤에 참여하였습니다. 단 한 명의 선수를 제외하고는 모든 선수가 마라톤을 완주하였습니다.

마라톤에 참여한 선수들의 이름이 담긴 배열 participant와 완주한 선수들의 이름이 담긴 배열 completion이 주어질 때, 완주하지 못한 선수의 이름을 return 하도록 solution 함수를 작성해주세요.

📑 첫번째 풀이 (정렬 이용)

import java.util.*;

class Solution {
    public String solution(String[] participant, String[] completion) {
        String answer = "";

        // 두 배열을 정렬 (사전순)
        Arrays.sort(participant);
        Arrays.sort(completion);

        // 원소값 비교하여 없는 원소값 찾음
        for(int i=0;i<completion.length;i++){
            if(!participant[i].equals(completion[i])){
                answer = participant[i];
                break;
            }
        }
        // 마지막 원소값이 미완주자인 경우
        if(answer.equals("")) //true
            answer = participant[participant.length-1];

        return answer;
    }
}

먼저, 두 배열을 똑같이 사전순으로 정렬을 하고, 두 배열을 비교하여 completion 완주자 배열에 없는 원소값을 찾는다(미완주자)

마지막 원소값이 미완주자라면, answer 문자열이 빈 문자열인지 확인(true)하고, 참가자 배열의 마지막 인덱스값을 answer에 저장한다.

📑 두번째 풀이 (HashMap 이용)

import java.util.*;

class Solution {
    public String solution(String[] participant, String[] completion) {

        // HashMap 생성
        Map<String, Integer> map = new HashMap<>();

        // 참가자 배열을 순회하며 해시맵에 각 참가자의 이름과 수를 기록
        for(String num:participant){
            map.put(num, map.getOrDefault(num, 0) + 1);
        }

        // 완주자 배열을 순회하며 해시맵에서 각 완주자의 이름을 찾아 수를 하나씩 감소
        for (String c : completion) {
            map.put(c, map.get(c) - 1);
        }

        // 해시맵에서 값이 1인 키를 찾아 그 이름이 완주하지 못한 선수
        for (String key : map.keySet()) {
            if (map.get(key) == 1) {
                return key; // 완주하지 못한 선수
            }
        }

        return "";
    }
}

❗❗ Map 인터페이스의 메서드

1. map.put(key, value)

• 키와 값을 맵에 추가하거나 업데이트 // 키에 값을 저장
• 키가 이미 맵에 존재하면 해당 기존값 반환
• 키가 없으면, null 반환

2. map.get(key)

• 키에 해당하는 값을 반환
• 없으면, null 반환

👀 문제 출처

📑 풀이

import java.util.HashSet;

class Solution {
    public int solution(int[] nums) {
        int length = nums.length; // 폰켓몬 종류 번호 담긴 배열의 길이
        int count = length/2; // 가질 수 있는 폰캣몬 수

        // 중복 제거해주는 HashSet 선언
        HashSet<Integer> ponketmon = new HashSet<>();

        // 중복 제거해서 HashSet에 추가
        for(int num:nums){
            ponketmon.add(num);
        } 

        // 폰켓몬 종류 번호의 개수 구하기
        return Math.min(ponketmon.size(),count);
    }
}

같은 번호를 가진 폰켓몬 중복 없애기위해 HashSet 사용

📘 HashSet

• 자바의 컬렉션 프레임워크에 속하는 객체
• 집합을 표현하는 자료 구조
• 중복 허용하지 않음

👀 문제 출처

📘 H-index 공식

1. 연구자가 발표한 논문들(배열)을 인용 횟수에 따라 내림차순 or 오름차순 정렬
2. 인용 횟수와 순위를 비교
3. 인용 횟수가 순위보다 크거나 같은지(>=) 확인
4. h번째 논문의 인용횟수가 h번 이상이면, 그 연구자의 H-index는 h로 설정

📑 나의 풀이 (int 배열 이용)

import java.util.Arrays;

class Solution {
    public int solution(int[] citations) {
        int answer = 0;
        int j = 0;

        // 오름차순 정렬
        Arrays.sort(citations);

        // H-index 값 계산 
        for(int i=citations.length-1;i>=0;i--){
            if(citations[i]>=j+1){
                answer++;
            }
            j++;
        }
        return answer;
    }
}

먼저, Arrays.sort() 메소드는 기본적으로 오름차순 정렬이며, int는 primitive type(원시타입)이라 comparaotr 같은 객체 기반 메소드가 적용되지 않기 때문에, 내림차순 정렬 후, 뒤에 인덱스부터 뒷 순위와 하나씩 비교하여 H-index를 구함.

📑 나의 풀이 (Integer 객체 배열 이용)

import java.util.*;

class Solution {
    public int solution(int[] citations) {
        int answer = 0;

        // Integer 객체 배열로 변환
        Integer[] arr = new Integer[citations.length];

        for(int i=0;i<citations.length;i++){
            arr[i] = citations[i];
        }

        // 내림차순 정렬
        Arrays.sort(arr, Comparator.reverseOrder());

        // H-index 계산
        for(int i=0;i<arr.length;i++){
            if(arr[i]>=i+1){
                answer++;
            }else break;
        }
        return answer;
    }
}

내림차순 정렬을 사용해보기위해, Integer 객체 배열로 변환하여 다시 풀어보았다. Integer 객체 배열을 사용했을 때는 기본형인 int를 객체로 감싸는 작업인 boxing과, 객체에서 기본형값을 꺼내는 unboxing 작업이 필요했다.

따라서, 이런 작업이 필요없는 int[] 배열을 사용했을 때, 속도와 메모리 측면에서 훨씬 효율적이었다.

Integer[] 배열을 사용하는 이유는 null값을 저장할 수 있기 때문에 값이 없거나 초기화되지 않은 상태를 표현하기위해서는 Integer[]를 사용해야한다.

❗❗ Comparator.reverseOrder() 와 collection.reverseOrder() 차이?

두 메소드 다 내림차순 정렬시 사용하지만,comparator.reverseOrder() 주로 배열에 사용되며, collection.reverseOrder()는 리스트에서 주로 사용된다.

👀 문제 출처

• 타입 정의 파일
• 특정 모듈이나 라이브러리 타입 정보를 정의하는데 사용
• JavaScript 코드에 대한 타입 정보를 제공 >> TypeScript 컴파일러가 코드의 타입을 이해하고 타입 검사를 수행할 수 있도록 도와줌
• 타입스크립트 코드에서 해당 모듈을 사용할 때, .d.ts 파일에 정의된 타입 정보를 기반으로 타입 추론이 이루어짐

📘 .d.ts 파일의 역할

1. 타입 정보 제공

: 외부 라이브러리의 함수, 클래스, 인터페이스 등에 대한 타입 정보를 정의

2. 타입 추론 지원

: JavaScript로 작성된 코드에 대한 타입 추론을 지원하여, TypeScript로 작성된 코드에서 해당 라이브러리를 안전하게 사용할 수 있게 함

📘 .d.ts 파일 만드는 방법

1. 타입 정의

// myLibrary.d.ts
declare function greet(name: string): string;

• declare function :이 함수가 어디선가 정의되어 있다
• greet(name: string): greet : 함수는 name이라는 매개변수를 받고, 이 매개변수의 타입이 string이라는 걸 알려줌
• : string: 이 부분은 greet 함수가 문자열을 반환한다는 걸 의미

2. 모듈 정의

// myLibrary.d.ts
declare module "my-library" {
    export function greet(name: string): string;
}

3. 인터페이스와 타입 정의

// shapes.d.ts
interface Rectangle {
    width: number;
    height: number;
}

declare function calculateArea(rect: Rectangle): number;

📌 정리

• .d.ts 파일은 여러 함수, 모듈, 인터페이스, 클래스 등에 대한 타입 정보를 한 곳에서 모아서 정의해주는 역할을 한다.
• 이를 통해 코드를 사용할 때 안전성과 편리함을 높일 수 있다.

• 함수나 클래스가 여러 타입을 받을 수 있게 해주는 방법 : 예를 들어, 숫자를 담는 배열과 문자열을 담는 배열을 만드려고 할때, 제네릭을 사용하면 하나의 함수 or 클래스를 만들어 어떤 타입의 배열이든 처리 가능!
• 제네릭을 사용하면 코드를 더 유연하고 재사용 가능해짐

function printArray<T>(items: T[]) {
    items.forEach(item => console.log(item));
}

• <T>
  • 변수 이름 바로 뒤에 <T> 붙임
  • 타입 매개변수
  • T는 나중에 어떤 타입이든 대체할 수 있는 자리표시자

📘 Map

const stock = new Map<string, number>(); //Map 객체 생성 
stock.set('g001', 1);
stock.set('g002', 2);
console.log(stock.get('g001'));
console.log(stock.get('g002'));

• Map은 키(key)로는 문자열(string), 값(value)으로는 숫자(number)를 가지는 자료구조, 자바스크립트에서 제공하는 특별한 객체
• stock.set('g001', 1); : 키 'g001'에 대해 값 1을 추가

📘 Set

• 고유한 값의 집합을 나타내는 객체
• 중복된 요소 추가 불가능, 동일한 값이 추가되면 무시
• 값이 삽입된 순서를 기억
• 다양한 타입 저장 가능
• 빠른 조회 가능
• 타입을 지정하지 않으면 Set 안에 숫자, 문자열 등 다양한 타입의 값을 모두 포함할 수 있음
• 배열과 비슷하지만 수학에서 집합에 해당하는 자료구조

  const mySet =  new Set<number>(); // 타입을 생성자에서 지정
  

// 값 추가 mySet.add(1); mySet.add(2); mySet.add(3); mySet.add(2); // 중복이므로 무시됨

console.log(mySet); // Set(3) { 1, 2, 3 }

// 값 조회 console.log(mySet.has(2)); // true console.log(mySet.has(4)); // false

// 값 삭제 mySet.delete(2); console.log(mySet); // Set(2) { 1, 3 }

// Set의 크기 console.log(mySet.size); // 2

// Set 순회 mySet.forEach(value => { console.log(value); // 1, 3 });

- 타입 지정 안 하는 경우
:  Set 안에 숫자, 문자열 등 다양한 타입의 값을 모두 포함

const mixedSet = new Set();

mixedSet.add(1); // 숫자 mixedSet.add("hello"); // 문자열 mixedSet.add(true); // 불리언 mixedSet.add({ key: "value" }); // 객체

console.log(mixedSet); // Set(4) { 1, "hello", true, { key: "value" } }

• 타입스크립트에서 타입을 추론하고 조합하는 데 유용하게 사용되는 기능

📘 typeof 연산자

• 이미 선언된 변수나 객체의 타입을 가져오는 데 사용
• 런타임 객체의 타입을 컴파일타임 타입으로 변환
• 변수의 타입을 가져와서 새로운 타입을 정의
• 코드가 변경되더라도 타입이 자동으로 업데이트되기 때문에, 코드의 안전성과 유지보수성을 높이는 데 큰 도움이 됨!

const person = {
    name: "Alice",
    age: 30
};

/// person 변수가 가지는 타입을 가져옴
// 새로운 타입으로 정의
type PersonType = typeof person; // { name: string; age: number; }

📘 keyof 연산자

• 객체의 속성 이름을 타입으로 가져올 수 있음
• 속성 이름을 나타내는 문자열 리터럴 타입을 정의
• 문자열 리터럴 타입으로, 타입들 중 하나의 값을 가지면 됨 😀 즉, PersonKeys는 "name" 또는 "age"라는 두 개의 문자열 값을 가짐!

  type PersonKeys = keyof PersonType; // "name" | "age"

const car = {
    make: "Toyota",
    model: "Camry",
    year: 2020
};

// 1. car 객체의 타입을 정의
type CarType = typeof car; 
// { make: string; model: string; year: number; }

// 2. CarType의 키를 가져옴
type CarKeys = keyof CarType; 
// "make" | "model" | "year"

// 3. 속성 값을 가져오는 함수 정의
function getCarValue(key: CarKeys) {
    return car[key]; // car 객체의 속성에 접근
}

// 4. 함수 호출
console.log(getCarValue("make"));  // "Toyota"
console.log(getCarValue("model")); // "Camry"
console.log(getCarValue("year"));  // 2020

• 여러 타입을 결합하여 모든 속성을 포함. type A = B & C;
• 두 개 이상의 타입을 결합하여, 모든 타입의 속성을 포함하는 새로운 타입을 정의할 때 사용 😀 즉, 두개의 타입을 결합> 하나의 타입 EmployeePerson으로 새로 정의해서 사용

  interface Person {
    name: string;
    age: number;
  }
  

interface Employee { employeeId: number; }

type EmployeePerson = Person & Employee;

let employee: EmployeePerson = { name: "Alice", age: 30, employeeId: 12345 }; // 올바른 값

## 📘 타입을 여러 개로 나누고 인터섹션 타입을 사용하는 이유?

🖐🏻 타입을 하나로 합쳐서 사용하면 될거같은데, 왜 굳이 두개의 타입을 결합해서 새로운 타입을 만들어 사용할까?

#### 1. 모듈화와 재사용성
타입을 별개로 정의하면, 그 타입들을 다른 곳에서 재사용 가능!

#### 2. 유지보수
타입을 개별적으로 정의하면, 나중에 변경이 필요할 때 더 쉽게 수정 가능

#### 3. 명확한 의도
각 타입이 무엇을 의미하는지를 명확히 구분가능하여, 코드의 가독성 향상

#### 4. 타입 안전성
인터섹션을 사용하면 서로 다른 타입의 조합을 명확히 정의, 오류 더 잘 잡아낼 수 있음

---------
## 📘 리터럴 타입과 객체타입의 교집합

- 리터럴 타입: 교집합은 두 타입에서 공통적으로 포함된 값만 가능.

type A = '바나나' | '바닐라'; type B = '바나나' | '딸기'; type C = A & B; // C는 '바나나'만 가능

- 객체 타입: 교집합은 두 타입의 모든 속성을 포함

interface Person { name: string; age: number; }

interface Employee { employeeId: number; }

type EmployeePerson = Person & Employee; ```

• 여러 타입 중 하나를 허용하는 타입을 정의할 때 사용
• 변수나 매개변수가 여러 타입 중 하나의 값을 가질 수 있도록 함
• 유니온 타입을 사용하면 변수가 어떤 값으로 초기화되든지, 그 값이 정의된 타입 중 하나여야 함 😀 즉 아래 코드에는 타입이 문자열이거나 숫자이면 됨!

type StringOrNumber = string | number;

let value: StringOrNumber;

value = "Hello"; // 올바른 값
value = 42;     // 올바른 값
value = true;   
// 오류: Type 'boolean' is not assignable to type 'StringOrNumber'

• 특정한 값만을 허용하는 타입
• 문자열, 숫자, 불리언과 같은 기본 타입을 기반으로 하여, 특정 값만을 갖도록 제한할 수 있음
• 더 강력한 타입 체크가 가능해지며, 의도한 값만 사용하게 되어 코드의 품질이 향상

1. 문자열 리터럴 타입

type Direction = "up" | "down" | "left" | "right";

let move: Direction;

move = "up";    // 올바른 값
move = "down";  // 올바른 값
move = "left";  // 올바른 값
move = "right"; // 올바른 값
move = "forward"; 
// 오류: Type '"forward"' is not assignable to type 'Direction'

2. 숫자 리터럴 타입

type StatusCode = 200 | 404 | 500;

let code: StatusCode;

code = 200; // 올바른 값
code = 404; // 올바른 값
code = 500; // 올바른 값
code = 300; // 오류: Type '300' is not assignable to type 'StatusCode'

• 200 , 404, 500은 초기화값이자 타입,
• 타입스크립트는 자동으로 이 값들이 숫자 타입임을 인식

3. 불리언 리터럴 타입

type IsEnabled = true | false;

let enabled: IsEnabled;

enabled = true;  // 올바른 값
enabled = false; // 올바른 값
enabled = null;  // 오류: Type 'null' is not assignable to type 'IsEnabled'

• 타입스크립트에서 특정 값들의 집합을 정의하는데 사용되는 데이터 구조

• 관련된 상수 값들의 집합

• 기본적으로 숫자 값을 자동으로 할당

• 초기화 시, 이름을 붙여주면 코드의 의미를 명확하게 전달 및 잘못된 값을 넣을 위험 방지

• 코드의 가독성을 높이고, 유지보수를 쉽게 하며, 오류를 방지하고, 타입 안전성을 보장

1. 기본 Enum

enum Direction {
    Up,    // 0
    Down,  // 1
    Left,  // 2
    Right  // 3
}

let move: Direction = Direction.Up;

console.log(move); // 1

• 초기화값에 이름을 주는 방식으로 각 값을 정의

2. 문자열 Enum

enum Color {
    Red = "RED",
    Green = "GREEN",
    Blue = "BLUE"
}

• 함수의 매개변수와 반환값의 타입을 직접 지정하는 방법

  function greet(name: string): string {
    return `Hello, ${name}!`;
  }
  

const message: string = greet("Alice"); // "Hello, Alice!"

- (name: string) : 매개변수의 타입
- : string : 반환값의 타입

---------

## 📘 인터페이스를 사용한 함수 타입 정의

- 여러 개의 함수를 동일한 타입으로 묶을 때 유용

interface Greet { // ❗❗ 함수 인터페이스 (name: string): string; // 앞은 매개변수타입, 뒤 반환값의 타입 }

const greet: Greet = (name) => { return Hello, ${name}!; };

const message = greet("Charlie"); // "Hello, Charlie!"

- const greet: Greet = (name) => 
: greet이라는 변수를 선언하여, Greet라는 인터페이스를 타입으로 가짐, (name)이라는 문자열을 매개변수로 받아, 문자열를 반환함

----
## 📘 타입 별칭을 사용한 함수 타입 정의

type GreetFunction = (name: string) => string;

const greet: GreetFunction = (name) => { return Hello, ${name}!; };

const message = greet("Bob"); // "Hello, Bob!"

- type 키워드를 사용하여 함수 타입을 별칭으로 정의
- GreetFunction 이라는 이름의 타입 별칭을 정의
- (name: string) : 매개변수의 타입 정의
- => string : 반환값의 타입 정의 

1. number : 모든 숫자를 나타냄
2. string : 문자열, 작은따옴표('), 큰따옴표("), 백틱(```)을 사용해 생성 가능
3. boolean : 참 or 거짓을 나타냄
4. null : 의도적으로 값이 없음(내가 주는 값 / 수를 초기화할 때 null을 할당하면, 그 변수는 "현재는 값이 없다"는 의미)
5. undefined : 변수 선언되었으나, 초기화 하지 않아 값이 할당되지 않은 상태
6. void : 주로 함수에서 반환 값이 없음을 나타냄.

   function logMessage(message: string): void {
    console.log(message);
   }

7. symbol : 고유하고 변경 불가능한 값, 주로 객체의 고유한 프로퍼티 키 만들 때 사용

   let uniqueId: symbol = Symbol("id");

8. bigint : 큰 정수를 나타내는 타입, number 타입의 범위를 초과하는 정수

   let bigNumber: bigint = 1234567890123456789012345678901234567890n;

📘 배열과 튜플

1. 배열 (Array)

• 동일한 타입의 요소를 순차적으로 저장하는 자료 구조
• 배열은 크기가 없다(빈 배열로 해도 오류X)

  // 숫자 배열
  let numbers: number[] = [1, 2, 3, 4, 5];
  

// 문자열 배열 let fruits: string[] = ["apple", "banana", "cherry"];

// 여러 타입을 포함하는 배열 (any 사용) let mixed: any[] = [1, "apple", true];

### 2. 튜플 (Tuple)
- 고정된 수의 요소를 가진 배열
-  각 요소는 서로 다른 타입

// 튜플: 문자열과 숫자를 포함하는 고정된 길이의 배열 let person: [string, number] = ["Alice", 30];

// 튜플의 요소 접근 console.log(person[0]); // "Alice" console.log(person[1]); // 30

// 잘못된 타입의 요소 할당 시 오류 발생 // person[0] = 123; // 오류: Type 'number' is not assignable to type 'string'

----------

## 📘 객체타입
### 1. 인터페이스 (Interface)
- 객체의 구조를 정의하는 방법(설명서)으로, 속성과 타입을 명시

interface Person { name: string; age: number; isStudent?: boolean; // 선택적 속성 }

// 객체 생성 const user: Person = { name: "Alice", age: 30, };

// 선택적 속성 사용 const student: Person = { name: "Bob", age: 20, isStudent: true, // 선택적으로 추가 };

### 2. 타입 별칭 (Type Alias)
- 객체의 구조를 정의하는 또 다른 방법으로, type 키워드를 사용
- 인터페이스와 비슷하지만, 더 다양한 형태의 타입을 정의

type Car = { brand: string; model: string; year: number; };

const myCar: Car = { brand: "Toyota", model: "Camry", year: 2022, };

-------

## 📘 any
- 타입스크립트에서 가장 유연한 타입으로, 어떤 값이든 허용할 수 있는 타입
- 타입오류가 사라짐
- 필요한 경우에만 사용하고, 가능한 구체적인 타입을 지정하는 것이 좋다
(기존 자바스크립트 코드에서 타입스크립트를 도입할 때 유용하게 사용할 수 있어. 처음에는 any로 타입을 지정한 후, 점차적으로 더 구체적인 타입으로 변경 등)

let value: any;

// 다양한 타입의 값 할당 가능 value = 42; // 숫자 value = "Hello, world!"; // 문자열 value = true; // 불리언 value = { name: "Alice" }; // 객체