C# 코딩테스트 강좌, 문자열 찾기

문제 설명

여러분은 문자열 S에서 특정 문자열 P가 몇 번 나타나는지를 찾아야 합니다. 문자열 P는 문자열 S에 여러 번 나타날 수 있으며, 겹치는 경우도 있을 수 있습니다. 주어진 문자열 S의 길이는 1 이상 100,000 이하이며, 문자열 P의 길이는 1 이상 100 이하입니다. 대소문자는 구별하지 않습니다.

입력 형식

  • 첫 번째 줄: 문자열 S (1 ≤ |S| ≤ 100,000)
  • 두 번째 줄: 문자열 P (1 ≤ |P| ≤ 100)

출력 형식

모든 발생의 수를 정수로 출력하세요.

예제

입력

    abCabcABCabc
    abc
    

출력

    4
    

문제 풀이 과정

1. 문제 이해하기

이 문제는 주어진 문자열 S에서 문자열 P가 몇 번 등장하는지를 확인하는 것입니다. 문자열이 대소문자를 구분하지 않기 때문에, 문제를 해결하기 위해 두 문자열 모두 소문자로 변환하여 비교해야 합니다.

2. 접근 방법

문자열 검색 문제는 여러 접근 방법이 있지만, 우리는 간단한 반복문을 사용하여 직접적으로 해결해 보겠습니다. 다음과 같은 절차로 문제를 해결할 것입니다:

  1. 문자열 S를 소문자로 변환합니다.
  2. 문자열 P를 소문자로 변환합니다.
  3. 반복문을 통해 문자열 S에서 문자열 P를 찾습니다.
  4. 각 발생 시 카운트를 증가시킵니다.

3. 알고리즘 설계

알고리즘의 복잡도는 O(n*m)입니다. 여기서 n은 문자열 S의 길이, m은 문자열 P의 길이입니다. 두 문자열을 직접 비교하기 때문에, 최악의 경우 모든 인덱스에서 문자열 P를 탐색해야 할 수 있습니다.

4. C# 코드 구현

아래는 C# 코드 예시입니다.

    using System;

    class Program
    {
        static void Main(string[] args)
        {
            string S = Console.ReadLine();
            string P = Console.ReadLine();

            // 대소문자를 구분하지 않기 위해 소문자로 변환
            S = S.ToLower();
            P = P.ToLower();

            int count = 0;
            int position = 0;

            while ((position = S.IndexOf(P, position)) != -1)
            {
                count++;
                position++; // 겹치는 경우를 고려하여 위치를 한 칸 이동
            }

            Console.WriteLine(count);
        }
    }
    

5. 코드 설명

코드는 다음과 같은 단계를 포함합니다:

  1. 사용자로부터 문자열 S와 P를 입력받습니다.
  2. 문자열 S와 P를 소문자로 변환하여 비교를 용이하게 합니다.
  3. while 루프를 통해 문자열 S에서 P의 위치를 찾습니다.
  4. S.IndexOf() 메서드를 사용하여 현재 위치부터 P의 위치를 찾습니다. 찾은 위치가 -1이 아닌 경우, 카운트를 증가시키고 다음 위치로 이동합니다.
  5. 모든 발생 수를 출력합니다.

성능 고려사항

이 코드의 시간 복잡도는 O(n*m)이며, 이는 문자열 S의 길이와 P의 길이에 따라 달라집니다. 만약 S의 길이가 100,000이고 P의 길이가 100이라면, 최악의 경우 10,000,000 연산이 요구될 수 있습니다. 이는 다소 비효율적일 수 있습니다.

따라서, 만약 성능을 더욱 개선하고 싶다면 KMP(Knuth-Morris-Pratt) 알고리즘과 같은 문자열 검색 알고리즘을 고려해볼 수 있습니다. KMP 알고리즘은 O(n + m)의 시간 복잡도를 가지며, 더 효율적인 검색을 가능하게 합니다.

5-1. KMP 알고리즘 개요

KMP 알고리즘은 부분 문자열 검색을 위한 효율적인 방법입니다. 이 알고리즘은 아래와 같은 원리를 이용합니다:

  • 먼저, 패턴 문자열 P의 부분 일치를 저장하는 배열을 생성합니다.
  • 문자열 S를 탐색하면서, 만약 불일치가 발생했을 때 패턴 문자열에서 몇 개의 문자를 건너뛸 수 있는지를 계산합니다.

5-2. KMP 알고리즘 C# 구현

아래는 KMP 알고리즘을 구현한 C# 코드입니다.

    using System;

    class Program
    {
        static void Main(string[] args)
        {
            string S = Console.ReadLine();
            string P = Console.ReadLine();

            // 대소문자를 구분하지 않기 위해 소문자로 변환
            S = S.ToLower();
            P = P.ToLower();

            int count = KMP(S, P);
            Console.WriteLine(count);
        }

        static int KMP(string S, string P)
        {
            int m = P.Length;
            int n = S.Length;
            int count = 0;

            // LPS 배열 초기화
            int[] lps = new int[m];
            ComputeLPSArray(P, m, lps);

            int i = 0; // S의 인덱스
            int j = 0; // P의 인덱스

            while (i < n)
            {
                if (P[j] == S[i])
                {
                    i++;
                    j++;
                }

                if (j == m)
                {
                    count++;
                    j = lps[j - 1];
                }
                else if (i < n && P[j] != S[i])
                {
                    if (j != 0)
                        j = lps[j - 1];
                    else
                        i++;
                }
            }
            return count;
        }

        static void ComputeLPSArray(string P, int m, int[] lps)
        {
            int len = 0;
            int i = 1;
            lps[0] = 0;

            while (i < m)
            {
                if (P[i] == P[len])
                {
                    len++;
                    lps[i] = len;
                    i++;
                }
                else
                {
                    if (len != 0)
                        len = lps[len - 1];
                    else
                    {
                        lps[i] = 0;
                        i++;
                    }
                }
            }
        }
    }
    

6. KMP 알고리즘 코드 설명

위 코드는 다음과 같은 절차로 작동합니다:

  1. 우선 문자열 S와 P를 소문자로 변환합니다. 이를 통해 대소문자 구분을 없앱니다.
  2. KMP 메서드를 호출하여 문자열 P가 문자열 S에 몇 번 나타나는지를 탐색합니다.
  3. KMP 메서드 내부에서 LPS 배열을 생성합니다. LPS 배열은 패턴 P의 접두사와 접미사의 최대 길이를 저장합니다.
  4. 문자열 S를 스캔하면서 패턴 P의 매칭을 진행합니다. 매칭이 성공하면 카운트를 증가시키고, 매칭이 실패하면 LPS 배열을 참조하여 위치를 조정합니다.

결론

이번 강좌에서는 C#을 이용하여 문자열에서 특정 문자열을 찾는 문제를 해결하는 방법에 대해 알아보았습니다. 간단한 반복문을 이용한 접근부터 KMP 알고리즘으로의 확장까지, 문자열 검색 문제에 대한 기본 개념과 효율적인 접근 방법을 학습할 수 있었습니다. 이 문제를 해결하는 과정에서 다양한 코드 구현 방식과 알고리즘의 복잡도를 이해하는 데 도움이 되었기를 바랍니다.

참고 자료

C# 코딩테스트 강좌, 2 N 타일 채우기

안녕하세요! 오늘은 C# 코딩 테스트를 준비하는 모든 분들을 위해 2*N 타일 채우기 문제에 대한 자세한 문제 설명과 풀이 과정을 함께 알아보겠습니다. 이 문제는 동적 프로그래밍(Dynamic Programming)과 관련이 깊고, 문제 해결 능력을 기르는 데에 매우 유용합니다.

문제 설명

우리는 2*N 크기의 직사각형 칸을 가지고 있습니다. 우리의 목표는 2*1 크기의 타일을 사용하여 이 직사각형을 채우는 방법의 수를 계산하는 것입니다. 타일을 회전할 수 있으므로 각 타일을 세로 또는 가로로 배치할 수 있습니다.

입력

  • 정수 N (1 ≤ N ≤ 30) – 직사각형의 너비입니다.

출력

  • 2*N 직사각형을 타일로 채우는 방법의 수를 출력합니다.

문제의 이해

이 문제를 해결하기 위해서는 몇 가지 접근 방식을 고려해야 합니다. 직사각형을 타일로 채우는 경우의 수는 다음과 같이 생각할 수 있습니다:

1. 점화식 수립하기

2*N 직사각형을 채우는 방법은 두 가지로 나눌 수 있습니다:

  1. 가로로 2개의 타일을 사용하는 경우: 이 경우 나머지 직사각형의 크기는 2*(N-1)입니다.
  2. 세로로 1개의 타일을 사용하는 경우: 이 경우 나머지 직사각형의 크기는 2*(N-2)입니다.

따라서, 이를 수식으로 표현하면 다음과 같습니다:

    F(N) = F(N-1) + F(N-2)
    

여기서 F(N) 은 N 크기의 직사각형을 채우는 방법의 수를 의미합니다.

2. 초기 조건 설정

초기 조건은 다음과 같습니다:

  • F(1) = 1 (2*1 크기의 직사각형은 2*1 타일 또는 1*2 타일로 채울 수 있습니다.)
  • F(2) = 2 (2*2 크기의 직사각형은 2개 가로 타일 또는 2개 세로 타일로 채울 수 있습니다.)

C# 코드 구현

이제 위에서 수립한 점화식을 바탕으로 C#을 사용하여 알고리즘을 구현해보겠습니다.

    
    using System;

    class Program
    {
        static void Main()
        {
            int N = int.Parse(Console.ReadLine());
            Console.WriteLine(TileFilling(N));
        }

        static int TileFilling(int N)
        {
            if (N == 1) return 1;
            if (N == 2) return 2;

            int[] dp = new int[N + 1];
            dp[1] = 1;
            dp[2] = 2;

            for (int i = 3; i <= N; i++)
            {
                dp[i] = dp[i - 1] + dp[i - 2];
            }

            return dp[N];
        }
    }
    
    

코드 설명

위 코드에서 우리는 동적 프로그래밍 배열인 <code>dp</code>를 사용하여 N까지의 타일 채우기 방법 수를 저장합니다. 초기 조건을 통해 길이가 1과 2인 경우의 수를 설정한 후, 루프를 통해 점화식을 기반으로 계산을 수행합니다.

주요 함수 설명

  • Main(): 프로그램의 시작점으로 N 값을 입력받고 타일 채우기 방법의 수를 출력합니다.
  • TileFilling(int N): 주어진 N에 대해 타일을 채우는 방법의 수를 계산하여 반환합니다.

복잡도 분석

이 알고리즘의 시간 복잡도는 O(N)이며, 공간 복잡도는 O(N)입니다. 이는 N에 비례하여 실행 시간이 증가한다는 것을 의미하며, 배열을 사용하여 이전 결과를 저장하므로 효율적인 메모리 사용이 가능합니다.

테스트 케이스

다양한 N 값에 대해 알고리즘이 잘 작동하는지 확인해보겠습니다.

  • 입력: N = 1 → 출력: 1
  • 입력: N = 2 → 출력: 2
  • 입력: N = 3 → 출력: 3
  • 입력: N = 4 → 출력: 5
  • 입력: N = 5 → 출력: 8
  • 입력: N = 6 → 출력: 13

결론

오늘은 C#을 사용하여 2*N 타일 채우기 문제를 해결하는 방법에 대해 알아보았습니다. 이 문제는 동적 프로그래밍을 사용하여 해결할 수 있는 전형적인 예이며, 알고리즘적 사고를 기르는 데 큰 도움이 될 것입니다. 문제를 풀이하는 과정을 통해 여러분의 코딩 테스트 준비에 많은 도움이 되었길 바랍니다.

다음 시간에는 또 다른 흥미로운 알고리즘 문제를 가지고 찾아오겠습니다. 보시고 싶은 주제가 있다면 댓글로 알려주세요! 감사합니다.

C# 코딩테스트 강좌, 거짓말쟁이가 되긴 싫어

문제 설명

어떤 날의 거리에서 시작해 특정 지점으로 이동하는 도중에 여러 사람과의 대화에서 서로 다른 상태를 가진 사람들로부터 이야기를 듣게 된다.
이 사람들은 각각 사실과 거짓을 말할 수 있으며, 우리는 모두가 말하는 내용을 바탕으로 진실을 파악해야 한다.
주어진 데이터에 따라 자신의 위치를 결정하는 알고리즘을 구현하라.

문제 정의

N명이 있는 사람들 중, 각 사람이 자신이 아는 것에 대해 진실 또는 거짓을 말할 수 있다.
각 사람은 다른 사람의 정보에 따라 자신의 진실성을 정할 수 있어야 한다.
주어진 대화 정보를 바탕으로 특정 지점에서 진실을 이야기할 수 있는 가능한 인물의 수를 계산하라.

입력 형식

  • 첫 번째 줄에 사람의 수 N이 주어진다.
  • 두 번째 줄에는 사람들 간의 대화 정보가 주어진다. 각 정보는 “A B T/F” 형식으로, A는 정보 제공자, B는 정보 수신자, T는 진실, F는 거짓을 의미한다.

출력 형식

진실을 말할 수 있는 사람들의 총 수를 출력하라.

문제 풀이 강좌

1. 문제 이해

문제를 이해하기 위해, 먼저 제공되는 데이터의 의미를 분석해보자.
사람들은 서로 대화를 하며, A가 B에게 알리는 정보가 진실인지 거짓인지에 대한 명확한 규칙을 정해야 한다.
이럴 경우, 우리는 이 정보들을 그래프로 나타내고 DFS 또는 BFS와 같은 알고리즘을 활용하여 진실성을 판단할 수 있다.

2. 알고리즘 설계

정보의 전달 관계를 위한 그래프를 만들고, 대화 속에서 발생할 수 있는 모든 진실과 거짓의 경우의 수를 따져보아야 한다.
DFS (Depth First Search) 알고리즘을 이용하여, 각 사람을 따라가며 진실과 거짓을 전파하는 과정은 다음과 같다.

3. C# 코드 구현

        
        using System;
        using System.Collections.Generic;

        class Program
        {
            static void Main(string[] args)
            {
                // 입력 받기
                int N = int.Parse(Console.ReadLine());
                List> conversations = new List>();
                string line;
                while ((line = Console.ReadLine()) != null && line.Length > 0)
                {
                    var parts = line.Split(' ');
                    int A = int.Parse(parts[0]);
                    int B = int.Parse(parts[1]);
                    bool isTruth = parts[2].Equals("T");
                    conversations.Add(new Tuple(A, B, isTruth));
                }

                // 그래프 형성
                Dictionary>> graph = new Dictionary>>();
                foreach (var convo in conversations)
                {
                    if (!graph.ContainsKey(convo.Item1))
                        graph[convo.Item1] = new List>();
                    graph[convo.Item1].Add(new Tuple(convo.Item2, convo.Item3));
                }

                // DFS 실행
                HashSet visited = new HashSet();
                int truthfulCount = 0;

                void DFS(int person)
                {
                    if (visited.Contains(person)) return;
                    visited.Add(person);
                    truthfulCount++;
                    if (graph.ContainsKey(person))
                    {
                        foreach (var neighbor in graph[person])
                        {
                            if (neighbor.Item2) // 진실을 말하는 경우
                                DFS(neighbor.Item1);
                        }
                    }
                }

                foreach (var person in graph.Keys)
                {
                    if (!visited.Contains(person))
                    {
                        DFS(person);
                    }
                }

                // 결과 출력
                Console.WriteLine(truthfulCount);
            }
        }
        
        

4. 코드 설명

위의 C# 코드는 간단한 DFS 알고리즘을 활용하여 문제를 해결하는 방법을 보여준다.
먼저, 입력을 받고 사람들 간의 대화 정보로 그래프를 구성한다.
이후 각 사람에 대해 DFS를 실행하여, 진실을 말할 수 있는 사람의 수를 계산하고 그 결과를 출력한다.

5. 시간 복잡도 분석

이 알고리즘의 시간 복잡도는 O(V + E)이다.
여기서 V는 사람의 수, E는 대화의 수를 의미한다.
즉, 그래프의 모든 정점과 간선을 탐색하는 시간이 소요되기 때문에, 대체로 효율적이라고 볼 수 있다.

6. 코드 개선과 최적화

추가로 이 문제에서 최적화를 고려할 수 있는 방법으로는, DFS 대신 BFS를 사용할 수도 있다.
또한, 메모이제이션을 도입하여 이미 확인한 진실과 거짓의 결과를 저장해두면
향후 동일한 요청에 대해 빠르게 결과를 반환할 수 있다.

결론

이 강좌에서는 C#을 이용하여 주어진 문제를 해결하기 위한 알고리즘을 구축하고 이를 구현하는 방법을 알아보았다.
그래프 알고리즘과 DFS를 활용해 진실을 이야기할 수 있는 인물 수를 계산하는 과정을 통해
실제 코딩테스트에서 유용한 접근 방식을 익히게 되었다.
문제 해결 능력을 키우기 위해 다양한 문제 유형을 연습하고, 알고리즘에 대한 이해도를 높이는데 도움이 되길 바란다.

C# 코딩테스트 강좌, 버블 소트 프로그램 2

이 글에서는 C#으로 버블 소트 알고리즘을 구현하는 방식에 대해 설명합니다. 버블 소트는 가장 기본적인 정렬 알고리즘 중 하나로, 여러 가지 알고리즘 시험에서 자주 등장하곤 합니다. 이번 포스팅에서는 버블 소트의 동작 원리에 대한 자세한 설명과 함께 C#으로 구현한 예제를 살펴보겠습니다.

버블 소트란?

버블 소트는 배열의 인접한 요소를 비교하여 두 요소의 순서를 맞춰주는 간단한 정렬 알고리즘입니다. 이 과정에서 가장 큰(혹은 작은) 요소가 배열의 끝으로 ‘버블’처럼 떠오르는 모습을 연상할 수 있습니다. 이 알고리즘은 간단하게 구현할 수 있지만, 효율적인 정렬 알고리즘은 아닙니다. 시간 복잡도는 O(n^2)입니다.

문제 설명

주어진 정수 배열을 버블 소트 알고리즘을 사용하여 오름차순으로 정렬하시오.

입력

- 입력: 정수 배열 arr = [64, 34, 25, 12, 22, 11, 90]

출력

- 출력: 정렬된 배열 [11, 12, 22, 25, 34, 64, 90]

버블 소트 알고리즘 설명

버블 소트는 다음과 같은 과정을 거칩니다:

  1. 배열의 길이를 확인합니다.
  2. 두 개의 중첩된 루프를 사용하여 배열의 모든 요소를 반복합니다.
  3. 인접한 두 요소를 비교하고, 잘못된 순서인 경우 서로 교환합니다.
  4. 한 번의 전체 비교가 끝났을 때, 가장 큰 요소가 배열 끝으로 이동하게 됩니다.
  5. 이 과정을 N-1회 반복하면 배열이 정렬됩니다.

C#로 버블 소트 구현하기

이제 위의 과정을 C# 코드로 구현해 보겠습니다.


using System;

class Program
{
    static void Main()
    {
        int[] arr = { 64, 34, 25, 12, 22, 11, 90 };
        Console.WriteLine("원본 배열:");
        PrintArray(arr);
        
        BubbleSort(arr);
        
        Console.WriteLine("정렬된 배열:");
        PrintArray(arr);
    }

    static void BubbleSort(int[] arr)
    {
        int n = arr.Length;
        for (int i = 0; i < n - 1; i++)
        {
            for (int j = 0; j < n - i - 1; j++)
            {
                if (arr[j] > arr[j + 1])
                {
                    // Swap arr[j] and arr[j + 1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    static void PrintArray(int[] arr)
    {
        foreach (var item in arr)
        {
            Console.Write(item + " ");
        }
        Console.WriteLine();
    }
}

코드 설명

위 코드는 간단한 C# 콘솔 애플리케이션을 사용하여 버블 소트를 구현한 예시입니다.

  • BubbleSort(int[] arr): 주어진 배열을 정렬하는 메서드입니다. 이 메서드는 두 개의 중첩 루프를 사용하여 배열을 반복하면서 인접한 요소를 비교하고 교환합니다.
  • PrintArray(int[] arr): 배열의 요소를 출력하는 헬퍼 메서드입니다. 각 요소를 공백으로 구분하여 출력합니다.

결론

버블 소트는 배우고 이해하기 쉬운 정렬 알고리즘이지만, 실제로는 더 나은 성능을 가진 다른 알고리즘을 사용하는 것이 좋습니다. 그러나 코딩테스트 준비 과정에서 기본적인 정렬 알고리즘의 개념을 알고 이해하는 것은 중요합니다.

이 글이 다음 코딩테스트 준비에 도움이 되길 바랍니다. 질문이나 논의할 점이 있다면 댓글로 남겨 주시기 바랍니다!

C# 코딩테스트 강좌, 집합 표현하기

1. 문제 설명

이번 강좌에서는 C#을 활용하여 집합을 표현하는 문제를 다루겠습니다. 집합(Sets)은 데이터 구조에서 중복을 허용하지 않는 요소들의 모임을 나타내며, 특정 상황에서 유용하게 사용됩니다. 예를 들어, 사용자들의 고유 ID 목록이나 다양한 상품 코드 목록을 처리하는 경우에 집합을 효과적으로 사용할 수 있습니다.

문제: 집합의 표현

주어진 두 배열 AB가 있을 때, 두 배열의 합집합, 교집합, 차집합을 구하는 함수를 구현하세요. 함수는 다음과 같은 형식으로 정의됩니다:

public static void CalculateSets(int[] A, int[] B)

2. 문제 풀이 과정

이 문제를 해결하기 위해서는 각 집합 연산의 정의를 이해하고, C#의 집합을 어떻게 활용할 수 있는지에 대해 알아야 합니다.

2.1 집합의 정의

  • 합집합 (Union): 두 집합의 원소를 모두 포함하는 집합입니다.
  • 교집합 (Intersection): 두 집합에 공통으로 존재하는 원소들로 이루어진 집합입니다.
  • 차집합 (Difference): 첫 번째 집합에서 두 번째 집합의 원소를 제외한 집합입니다.

2.2 C#의 집합 클래스

C#에서는 HashSet 클래스를 이용해 집합을 쉽게 구현할 수 있습니다. HashSet은 중복을 허용하지 않으며, 정렬되지 않은 집합을 표현할 수 있습니다.

2.3 함수 구현

이제 문제에서 요구하는 함수 CalculateSets를 구현해 보겠습니다. 아래는 각 집합 연산을 구현하기 위한 코드입니다.

using System;
using System.Collections.Generic;

public class SetOperations
{
    public static void CalculateSets(int[] A, int[] B)
    {
        HashSet setA = new HashSet(A);
        HashSet setB = new HashSet(B);

        // 합집합
        HashSet union = new HashSet(setA);
        union.UnionWith(setB);
        Console.WriteLine("합집합: " + string.Join(", ", union));

        // 교집합
        HashSet intersection = new HashSet(setA);
        intersection.IntersectWith(setB);
        Console.WriteLine("교집합: " + string.Join(", ", intersection));

        // 차집합
        HashSet difference = new HashSet(setA);
        difference.ExceptWith(setB);
        Console.WriteLine("차집합: " + string.Join(", ", difference));
    }
}

3. 코드 설명

위 코드를 단계별로 설명하겠습니다.

3.1 HashSet 생성

먼저, 주어진 배열 AB를 이용해 각각의 HashSet을 생성합니다. 이렇게 하면 중복 된 원소가 제거된 상태의 집합을 얻을 수 있습니다.

HashSet setA = new HashSet(A);
HashSet setB = new HashSet(B);

3.2 합집합 계산

합집합을 구하기 위해서는 먼저 setA를 복사한 후 UnionWith 메서드를 사용하여 setB의 원소를 추가합니다.

HashSet union = new HashSet(setA);
union.UnionWith(setB);
Console.WriteLine("합집합: " + string.Join(", ", union));

3.3 교집합 계산

교집합은 setA의 복사본에서 IntersectWith 메서드를 호출하여 setB와의 교집합을 구합니다.

HashSet intersection = new HashSet(setA);
intersection.IntersectWith(setB);
Console.WriteLine("교집합: " + string.Join(", ", intersection));

3.4 차집합 계산

차집합은 ExceptWith 메서드를 사용하여 setB의 원소를 제거함으로써 계산합니다.

HashSet difference = new HashSet(setA);
difference.ExceptWith(setB);
Console.WriteLine("차집합: " + string.Join(", ", difference));

4. 전체 코드

마지막으로, 모든 내용을 포함한 전체 코드는 다음과 같습니다:

using System;
using System.Collections.Generic;

public class SetOperations
{
    public static void CalculateSets(int[] A, int[] B)
    {
        HashSet setA = new HashSet(A);
        HashSet setB = new HashSet(B);

        // 합집합
        HashSet union = new HashSet(setA);
        union.UnionWith(setB);
        Console.WriteLine("합집합: " + string.Join(", ", union));

        // 교집합
        HashSet intersection = new HashSet(setA);
        intersection.IntersectWith(setB);
        Console.WriteLine("교집합: " + string.Join(", ", intersection));

        // 차집합
        HashSet difference = new HashSet(setA);
        difference.ExceptWith(setB);
        Console.WriteLine("차집합: " + string.Join(", ", difference));
    }
}

class Program
{
    static void Main()
    {
        int[] A = { 1, 2, 3, 4, 5 };
        int[] B = { 4, 5, 6, 7, 8 };
        SetOperations.CalculateSets(A, B);
    }
}

5. 테스트 및 결과

위의 코드를 테스트하기 위해 Main 메서드에서 두 배열을 정의하고 CalculateSets 함수를 호출해 보았습니다.

주어진 배열 AB에 대한 결과는 다음과 같습니다:

합집합: 1, 2, 3, 4, 5, 6, 7, 8
교집합: 4, 5
차집합: 1, 2, 3

6. 마무리

이번 강좌에서는 C#을 이용하여 집합을 효과적으로 표현하고, 합집합, 교집합, 차집합의 연산을 수행하는 방법에 대해 배웠습니다. 이와 같은 집합 연산은 코딩테스트뿐 아니라, 다양한 알고리즘 문제를 해결하는 데 매우 유용한 접근 방법입니다. 또한, C#의 HashSet 클래스의 다양한 메서드를 활용하면 집합을 쉽게 다룰 수 있습니다. 향후 코딩테스트를 준비하시면서 집합의 개념과 활용에 대해 한 번 더 되새기는 것이 좋겠습니다.