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 클래스의 다양한 메서드를 활용하면 집합을 쉽게 다룰 수 있습니다. 향후 코딩테스트를 준비하시면서 집합의 개념과 활용에 대해 한 번 더 되새기는 것이 좋겠습니다.

C# 코딩테스트 강좌, 칵테일 만들기

이번 강좌에서는 ‘칵테일 만들기’라는 주제로 실제 코딩 테스트에서 자주 등장하는 문제를 다뤄보겠습니다. 이 문제는 다양한 알고리즘적 사고를 요구하며, C# 프로그래밍 언어를 통해 해결할 것입니다. 칵테일 만들기 관련 문제는 조합, 분할 정복, 최적화 문제 등 여러 가지를 포함할 수 있으며, 이 강좌에서는 특정 문제를 선정하여 단계별로 풀이하겠습니다.

문제 설명

당신에게 N가지 재료가 있습니다. 각각의 재료는 특정한 양의 알코올을 포함하고 있습니다. 또한 각각의 재료는 인덱스 1부터 N까지 부여되어 있습니다. 당신은 M (1 ≤ M ≤ N)가지의 재료를 선택하여 칵테일을 만들고자 합니다. 선택한 재료의 알코올 양의 합이 K (K는 주어진 정수)와 같아야 합니다. 당신의 목표는 다양한 조합을 찾아내어 가능한 모든 칵테일을 만들 수 있는 경우의 수를 계산하는 것입니다.

입력 형식

  • 첫 번째 줄에는 두 개의 정수 N (재료의 수), M (선택할 재료의 수)이 주어진다.
  • 두 번째 줄에는 N개의 정수로 각 재료의 알코올 양이 주어진다.
  • 세 번째 줄에는 목표하는 알코올 양 K가 주어진다.

출력 형식

가능한 칵테일 조합의 수를 1,000,000,007로 나눈 나머지를 출력한다.

예제 입력

5 3
1 2 3 4 5
5

예제 출력

5

문제 풀이 과정

이 문제를 해결하기 위해서는 여러 재료 조합을 만들고 그 조합의 알코올 합을 체크해야 합니다. C#에서 조합을 찾기 위한 방법으로는 재귀 호출을 활용할 수 있습니다. 아래는 이 문제를 해결하기 위한 기본적인 알고리즘 설계입니다.

1단계: 입력 파싱

먼저 입력된 데이터를 파싱하여 N, M, 재료의 알코올 양, K를 변수에 저장합니다.

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        var input = Console.ReadLine().Split();
        int N = int.Parse(input[0]);
        int M = int.Parse(input[1]);

        var alcohols = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
        int K = int.Parse(Console.ReadLine());
        
        // 향후 재귀 호출을 통해 조합을 찾아낼 것입니다.
    }
}

2단계: 조합을 찾기 위한 함수 구현

조합을 찾기 위해 재귀 함수를 구현하겠습니다. 이 함수는 매개변수로 현재 인덱스, 선택한 재료의 수와 현재까지의 알코올 양을 받을 것입니다.

static int CountCombinations(int[] alcohols, int N, int M, int K, int index, int count, int currentSum)
{
    if(count == M)
    {
        return currentSum == K ? 1 : 0;
    }
    
    if(index >= N)
    {
        return 0;
    }

    // 현재 재료를 선택하고 재귀 호출
    int includeCurrent = CountCombinations(alcohols, N, M, K, index + 1, count + 1, currentSum + alcohols[index]);
    // 현재 재료를 선택하지 않고 재귀 호출
    int excludeCurrent = CountCombinations(alcohols, N, M, K, index + 1, count, currentSum);

    return includeCurrent + excludeCurrent;
}

3단계: 메인 함수와 조합 호출

이제 메인 함수에서 위에서 정의한 조합 함수를 호출하여 결과를 출력하겠습니다. 또한, 결과를 1,000,000,007로 나누어 출력합니다.

static void Main(string[] args)
{
    var input = Console.ReadLine().Split();
    int N = int.Parse(input[0]);
    int M = int.Parse(input[1]);

    var alcohols = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
    int K = int.Parse(Console.ReadLine());

    long result = CountCombinations(alcohols, N, M, K, 0, 0, 0);
    const int MOD = 1000000007;

    Console.WriteLine(result % MOD);
}

완전한 소스 코드

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        var input = Console.ReadLine().Split();
        int N = int.Parse(input[0]);
        int M = int.Parse(input[1]);

        var alcohols = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
        int K = int.Parse(Console.ReadLine());

        long result = CountCombinations(alcohols, N, M, K, 0, 0, 0);
        const int MOD = 1000000007;

        Console.WriteLine(result % MOD);
    }

    static int CountCombinations(int[] alcohols, int N, int M, int K, int index, int count, int currentSum)
    {
        if(count == M)
        {
            return currentSum == K ? 1 : 0;
        }
        
        if(index >= N)
        {
            return 0;
        }

        // 현재 재료를 선택하고 재귀 호출
        int includeCurrent = CountCombinations(alcohols, N, M, K, index + 1, count + 1, currentSum + alcohols[index]);
        // 현재 재료를 선택하지 않고 재귀 호출
        int excludeCurrent = CountCombinations(alcohols, N, M, K, index + 1, count, currentSum);

        return includeCurrent + excludeCurrent;
    }
}

결론

이 알고리즘 문제는 조합과 재귀를 활용하여 간단한 접근법으로 해결할 수 있습니다. 여러 개의 재료를 조합하여 특정한 값을 만들 때 유용하게 사용할 수 있는 방식입니다. 코딩 테스트에서 자주 출제되므로 반드시 연습해보시길 권장합니다.

앞으로도 다양한 알고리즘 및 문제 해결 방식을 다룰 예정이니 많은 관심 부탁드립니다!

C# 코딩테스트 강좌, 주몽의 명령

안녕하세요! 이번 포스트에서는 C# 언어를 활용한 코딩 테스트 문제를 하나 풀어보겠습니다. 주제는 ‘주몽의 명령’입니다. 이 문제는 주몽이 명령을 내리는 상황을 시뮬레이션 하고, 이를 효율적으로 처리하는 알고리즘을 구현하는 과정입니다. 문제를 해결하는 방법과 코드 구현에 대해 자세히 설명하겠습니다.

문제 설명

주몽은 매번 전투를 하기 전에 전사들에게 명령을 내립니다. 각 전사는 자신이 받은 명령에 따라 임무를 수행합니다. 전사들은 주몽의 명령을 다음과 같이 해석합니다:

  • 전사의 고유 번호 (1부터 시작하는 양의 정수)
  • 명령의 내용 (어떠한 조작을 수행해야 하는지를 나타냄)

주몽은 N명의 전사와 M개의 명령을 가지고 있습니다. 명령은 다음과 같은 형식으로 주어집니다:

    1. ATTACK A B  // A번 전사가 B번 전사를 공격
    2. DEFENSE A   // A번 전사가 방어 자세를 취함
    3. RETREAT A    // A번 전사가 후퇴
    

각 전사가 성공적으로 임무를 수행할 경우 ‘SUCCESS’, 실패할 경우 ‘FAIL’로 결과를 출력해야 합니다. 전사는 매번 명령을 수행하기 전 자신이 흥미를 잃으면 명령을 수행하지 않습니다. 흥미는 시간이 지남에 따라 감소합니다. 만약 전사가 명령을 수행할 수 없는 상황이라면 ‘FAIL’을 출력해야 합니다.

입력 형식

입력은 다음과 같은 형식으로 주어집니다:

    N (전사 수)
    M (명령 수)
    흥미 감소율 (0 ~ 1)
    명령들 (M 개)
    

출력 형식

각 명령에 대해 결과를 출력합니다. 결과는 명령의 순서와 동일하게 나열됩니다.

문제 접근 방법

이 문제는 주어진 명령을 처리하고 각 전사가 명령을 수행할 수 있는지를 판단하는 알고리즘을 요구합니다. 문제 해결을 위해 다음과 같은 단계를 고려하겠습니다:

  1. 전사와 명령 리스트를 저장할 수 있는 자료구조를 만든다.
  2. 각 전사는 처음에 100%의 흥미를 가지고 있다고 가정한다.
  3. 주어진 흥미 감소율에 따라 전사의 흥미를 감소시키고, 각 명령을 처리하며 상태를 업데이트한다.
  4. 명령의 결과를 기반으로 성공 또는 실패를 기록한다.

구현

코드 예시

다음은 위의 접근 방법에 따라 C#으로 구현한 코드입니다:


using System;
using System.Collections.Generic;

namespace JumongCommand
{
    class Warrior
    {
        public int Id { get; set; }
        public double Interest { get; set; }

        public Warrior(int id)
        {
            Id = id;
            Interest = 1.0; // 100% 흥미
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            int N = int.Parse(Console.ReadLine());
            int M = int.Parse(Console.ReadLine());
            double interestDecayRate = double.Parse(Console.ReadLine());

            List warriors = new List();
            for (int i = 1; i <= N; i++)
            {
                warriors.Add(new Warrior(i));
            }

            List results = new List();
            for (int i = 0; i < M; i++)
            {
                string command = Console.ReadLine();
                string[] parts = command.Split(' ');

                if (parts[0] == "ATTACK")
                {
                    int attackerId = int.Parse(parts[1]);
                    int targetId = int.Parse(parts[2]);
                    ProcessAttack(warriors, results, attackerId, targetId);
                }
                else if (parts[0] == "DEFENSE")
                {
                    int defenderId = int.Parse(parts[1]);
                    ProcessDefense(warriors, results, defenderId);
                }
                else if (parts[0] == "RETREAT")
                {
                    int retreatId = int.Parse(parts[1]);
                    ProcessRetreat(warriors, results, retreatId);
                }

                // 흥미 감소 적용
                foreach (var warrior in warriors)
                {
                    warrior.Interest -= interestDecayRate;
                    if (warrior.Interest < 0)
                        warrior.Interest = 0;
                }
            }

            foreach (var result in results)
            {
                Console.WriteLine(result);
            }
        }

        static void ProcessAttack(List warriors, List results, int attackerId, int targetId)
        {
            var attacker = warriors[attackerId - 1];
            var target = warriors[targetId - 1];

            if (attacker.Interest > 0)
            {
                results.Add("SUCCESS");
            }
            else
            {
                results.Add("FAIL");
            }
        }

        static void ProcessDefense(List warriors, List results, int defenderId)
        {
            var defender = warriors[defenderId - 1];

            if (defender.Interest > 0)
            {
                results.Add("SUCCESS");
            }
            else
            {
                results.Add("FAIL");
            }
        }

        static void ProcessRetreat(List warriors, List results, int retreatId)
        {
            var retreatingWarrior = warriors[retreatId - 1];

            if (retreatingWarrior.Interest > 0)
            {
                results.Add("SUCCESS");
            }
            else
            {
                results.Add("FAIL");
            }
        }
    }
}

코드 설명

코드는 ‘Warrior’ 클래스를 정의하여 각 전사의 상태를 관리합니다. 전사는 고유 ID와 현재 흥미를 속성으로 갖습니다. 메인 프로그램에서는 전사 리스트와 명령 리스트를 차례대로 읽고, 각 명령을 처리하는 별도의 메소드를 호출하여 결과를 업데이트합니다.

결과 확인

명령이 완료된 후, 결과 리스트를 출력하여 최종 성공 또는 실패 결과를 확인합니다. 이와 같은 방식으로 전사들이 명령을 수행하고 리소스를 관리하는 과정을 간단하게 구현한 것입니다.

테스트 케이스

제대로 동작하는지 확인하기 위해 몇 가지 테스트 케이스를 만들 수 있습니다.

예시 입력

5
3
0.1
ATTACK 1 2
DEFENSE 3
RETREAT 4

예상 결과

SUCCESS
SUCCESS
SUCCESS

이와 같은 방식으로 다양한 입력을 테스트하여 알고리즘이 모든 상황에 올바르게 반응하는 지 확인할 수 있습니다.

마무리

이번 포스트에서는 ‘주몽의 명령’ 문제를 해결하기 위한 과정을 살펴보았습니다. 알고리즘의 구조와 구현 방법을 이해하고, 다양한 명령 처리에 대한 로직을 구축하는 것이 중요했습니다. 앞으로도 더 많은 알고리즘 문제를 통해 실력을 쌓아가시길 바랍니다. 감사합니다!

C# 코딩테스트 강좌, 연속 합 구하기

코딩테스트나 알고리즘 문제풀이를 준비하면서, 다양한 유형의 문제에 대한 이해와 접근 방식을 익히는 것이 중요합니다. 오늘은 연속 합 구하기 문제에 대해 깊이 있게 알아보도록 하겠습니다.

문제 설명

주어진 정수 배열에서 연속된 요소들의 합을 계산하여, 특정 기준에 도달하는 가장 짧은 연속 부분 배열을 찾는 문제를 살펴보겠습니다.

문제 정의


문제: 연속 합 구하기

주어진 정수 배열 nums와 정수 target가 주어질 때, 
target 이상의 합을 가지는 가장 짧은 연속 부분 배열의 길이를 반환합니다. 
만약 그 조건을 만족하는 부분 배열이 없다면 0을 반환합니다.

입력 예시:
nums = [2,3,1,2,4,3]
target = 7

출력 예시:
2 (부분 배열 [4,3]의 길이)

문제 풀이 접근 방법

이 문제를 해결하기 위해 두 가지 주요 접근 방법을 사용할 수 있습니다: 브루트포스(완전 탐색)와 투 포인터(슬라이딩 윈도우) 방법입니다. 여기서는 효율적인 해결을 위해 투 포인터 방법을 사용하겠습니다.

투 포인터 접근 방법

투 포인터 접근 방법은 배열을 탐색하면서 두 개의 포인터(왼쪽, 오른쪽)를 사용하여 원하는 조건을 만족하는 부분 배열을 찾아내는 방식입니다. 이 방법의 장점은 시간 복잡도가 O(n)으로 효율적이라는 점입니다.

단계별 풀이

  1. 초기화: 두 개의 포인터를 초기화합니다. 왼쪽 포인터 left는 0으로, 오른쪽 포인터 right는 0으로 설정합니다. 또한, 현재 합 currentSum을 0으로 설정하고, 최소 길이 minLength를 무한대로 초기화합니다.
  2. 조건 검사: right 포인터를 이용해 배열을 순회하면서 currentSumnums[right]를 더합니다. 그 후, currentSumtarget 이상인지 확인합니다.
  3. 부분 배열 조정: 만약 currentSumtarget보다 크거나 같다면, 최소 길이를 업데이트하고 left 포인터를 증가시키며 currentSum에서 nums[left]를 빼 줍니다. 이렇게 함으로써 가능한 짧은 부분 배열을 찾습니다.
  4. 종료 조건: right 포인터가 배열의 끝에 도달할 때까지 이 과정을 반복합니다.

함수 구현

이제 C# 코드를 통해 위의 논리를 실제로 구현해보겠습니다.


using System;

public class Solution {
    public int MinSubArrayLen(int target, int[] nums) {
        int left = 0;
        int currentSum = 0;
        int minLength = int.MaxValue;

        for (int right = 0; right < nums.Length; right++) {
            currentSum += nums[right];

            while (currentSum >= target) {
                minLength = Math.Min(minLength, right - left + 1);
                currentSum -= nums[left];
                left++;
            }
        }

        return minLength == int.MaxValue ? 0 : minLength;
    }
}

코드 설명

위의 C# 코드는 다음과 같은 방식으로 작동합니다:

  • 초기 변수 설정: leftcurrentSum, minLength를 초기화합니다.
  • 배열 순회: right 변수를 통해 배열을 순회하며 현재 요소를 currentSum에 추가합니다.
  • 조건 검사: currentSumtarget 이상인 경우, minLength를 업데이트하고 left 포인터를 증가시키며 currentSum에서 nums[left]를 빼줍니다.
  • 결과 반환: 최종적으로 minLength가 업데이트되지 않았다면 0을 반환하고, 그렇지 않으면 찾은 최소 길이를 반환합니다.

예제 테스트 케이스

이제 이 함수를 테스트하기 위한 몇 가지 예제 테스트 케이스를 작성해 보겠습니다.


public static void Main(string[] args) {
    Solution sol = new Solution();
    
    Console.WriteLine(sol.MinSubArrayLen(7, new int[] { 2, 3, 1, 2, 4, 3 })); // 출력: 2
    Console.WriteLine(sol.MinSubArrayLen(4, new int[] { 1, 4, 4 }));        // 출력: 1
    Console.WriteLine(sol.MinSubArrayLen(11, new int[] { 1, 1, 1, 1, 1, 1 })); // 출력: 0
    Console.WriteLine(sol.MinSubArrayLen(8, new int[] { 2, 3, 1, 2, 4, 3 })); // 출력: 2
}

결론

이번 강좌에서는 연속 합 구하기 문제를 통해 투 포인터를 활용한 문제 해결 접근 방법을 익혔습니다. 알고리즘 문제를 해결하기 위해서는 문제의 성격을 정확히 이해하고, 적절한 접근 방법을 선택하는 것이 중요합니다. 실전에서는 다양한 문제를 풀어보며 경험을 쌓고, 여러 알고리즘을 친숙하게 다룰 수 있도록 지속적으로 연습하는 것이 좋습니다.

여러분도 다양한 문제를 접하고 풀어보면서 알고리즘 감각을 키워보세요!