C# 코딩테스트 강좌, 삽입 정렬

서론

안녕하세요. 이번 강좌에서는 코딩테스트 준비에 유용한 정렬 알고리즘 중 하나인 ‘삽입 정렬(Insertion Sort)’에 대해 깊이 있게 다루어 보겠습니다. 정렬 알고리즘은 데이터 구조와 알고리즘 문제해결의 기초가 되는 중요한 주제입니다. 특히, 이론적 배경과 코드 구현, 그리고 문제 풀이의 구체적인 사례를 제시하여 독자 여러분의 이해를 돕고자 합니다.

삽입 정렬이란?

삽입 정렬은 데이터가 정렬된 상태에서 새 데이터를 삽입하는 방식으로 작동하는 정렬 알고리즘입니다. 주어진 데이터에서 하나씩 원소를 선택하여, 이미 정렬된 부분과 비교하면서 적절한 위치에 삽입합니다. 이 알고리즘은 매우 직관적이며, 구현하기도 쉽습니다.

삽입 정렬의 작동 원리

삽입 정렬은 다음과 같은 방식으로 작동합니다:

  1. 정렬되지 않은 리스트에서 첫 번째 원소를 선택합니다. 이 원소는 이미 정렬된 상태로 간주합니다.
  2. 다음 원소를 선택하여 정렬된 원소들과 비교합니다.
  3. 현재 선택한 원소가 정렬된 원소보다 작다면, 정렬된 리스트의 적절한 위치에 삽입합니다.
  4. 이 과정을 리스트의 끝까지 반복합니다.

삽입 정렬의 시간 복잡도

삽입 정렬의 시간 복잡도는 최악의 경우 O(n²)입니다. 그러나 데이터가 거의 정렬된 상태라면 평균적으로 O(n)의 성능을 보여줍니다. 이는 삽입 정렬이 다른 알고리즘들과 비교했을 때 장점이 될 수 있습니다. 특별한 경우에는 O(n)으로 동작하기 때문에 실제 문제에서는 종종 사용됩니다.

삽입 정렬의 C# 구현

이제 실제로 C#을 사용하여 삽입 정렬 알고리즘을 구현해 보겠습니다:


using System;

class Program
{
    static void InsertionSort(int[] arr)
    {
        for (int i = 1; i < arr.Length; i++)
        {
            int key = arr[i];
            int j = i - 1;

            // 현재 key보다 큰 원소를 한 칸씩 뒤로 이동
            while (j >= 0 && arr[j] > key)
            {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key; // key를 적절한 위치에 삽입
        }
    }

    static void Main()
    {
        int[] array = { 12, 11, 13, 5, 6 };
        InsertionSort(array);

        Console.WriteLine("정렬된 배열: ");
        foreach (int num in array)
        {
            Console.Write(num + " ");
        }
    }
}

문제 풀이: 주어진 배열 정렬하기

다음은 실제 코딩테스트에서 주어질 수 있는 문제의 예시입니다:

문제: 정수 배열이 주어졌을 때, 삽입 정렬을 사용하여 배열을 오름차순으로 정렬하시오.

입력 예: [64, 34, 25, 12, 22, 11, 90]

출력 예: [11, 12, 22, 25, 34, 64, 90]

위 문제를 해결하기 위해서는 앞서 설명한 삽입 정렬 알고리즘을 구현하면 됩니다. 주어진 배열을 삽입 정렬로 정렬해보겠습니다.


using System;

class InsertionSortExample
{
    static void InsertSort(int[] array)
    {
        for (int i = 1; i < array.Length; i++)
        {
            int key = array[i];
            int j = i - 1;

            while (j >= 0 && array[j] > key)
            {
                array[j + 1] = array[j];
                j--;
            }
            array[j + 1] = key;
        }
    }

    static void Main()
    {
        int[] nums = { 64, 34, 25, 12, 22, 11, 90 };
        InsertSort(nums);

        Console.WriteLine("정렬된 배열: ");
        foreach (var num in nums)
        {
            Console.Write(num + " ");
        }
    }
}

결론

이번 강좌에서는 삽입 정렬 알고리즘에 대해 깊이 이해하고, C#으로 구현하는 방법과 실제 문제를 해결하는 과정을 살펴보았습니다. 비교적 쉬운 이해와 구현 덕분에 삽입 정렬은 많은 코딩테스트 문제의 출제 원본으로 많이 사용됩니다. 이제 여러분도 삽입 정렬을 마스터했으니, 다양한 문제를 풀어보며 더욱 실력을 쌓아보세요!

C# 코딩테스트 강좌, 너비 우선 탐색

안녕하세요, 여러분! 오늘은 C#를 이용한 코딩테스트에서 중요하게 다뤄지는 알고리즘 중 하나인 너비 우선 탐색(BFS, Breadth-First Search)에 대해서 깊이 있게 알아보도록 하겠습니다. BFS는 그래프 또는 트리 데이터 구조를 탐색하는 알고리즘으로, 최단 경로 문제를 해결하거나, 특정 노드를 찾는 데 유용하게 쓰입니다.

1. 너비 우선 탐색(BFS)란?

BFS는 Queue(큐) 자료 구조를 사용하여 구현되는 탐색 알고리즘입니다. 이 알고리즘은 주어진 노드에서 시작하여 그 노드에 인접한 노드들을 탐색한 다음, 탐색한 노드의 인접 노드들을 다시 탐색하는 방식으로 진행됩니다. 이 방식은 점점 더 넓은 영역을 탐색하게 되어 ‘너비 우선’이라는 이름이 붙여졌습니다.

2. BFS의 특징

  • 최단 경로 탐색: BFS는 모든 간선의 가중치가 동일할 때, 최단 경로를 찾기에 적합합니다.
  • 햇빛 탐사: BFS는 가까운 노드를 먼저 방문하기 때문에, ‘햇빛’이 비추는 방식으로 탐색합니다.
  • 큐를 사용: 탐색 순서를 저장하기 위해 큐를 사용하여, 방문해야 할 노드를 FIFO(선입 선출) 방식으로 관리합니다.

3. BFS의 작동 원리

BFS의 기본적인 작동 방식은 다음과 같습니다:

  1. 탐색을 시작할 노드를 큐에 추가하고 방문 표기를 합니다.
  2. 큐에서 노드를 제거하고, 이 노드의 인접한 모든 노드를 체크합니다.
  3. 인접한 노드가 아직 방문하지 않았다면, 큐에 추가하고 방문 표기를 합니다.
  4. 큐가 비어있지 않을 때까지 2번과 3번 과정을 반복합니다.

4. 문제 풀이

이번에는 실제 코딩 테스트에서 나올 법한 문제를 통해 BFS를 이해해보겠습니다.

문제: ‘단지 번호 붙이기’

우리는 n × n 크기의 0과 1로 이루어진 배열을 가지고 있습니다. 여기서 1은 집이 존재하는 곳을 의미하고, 0은 집이 없는 곳을 의미합니다. 연결된 집을 하나의 단지로 보고, 단지의 번호를 붙이기 위해 BFS를 사용합니다. 같은 단지에 속한 집의 개수를 세어 각 단지의 크기를 출력하는 문제입니다.

입력

5
01101
11011
11100
00011
00000

출력

3
2
1

5. C# 코드 구현

이 문제를 BFS를 이용하여 해결하기 위한 C# 코드를 아래와 같이 작성해보았습니다.


using System;
using System.Collections.Generic;

class Program
{
    static int n;
    static int[,] map;
    static bool[,] visited;
    static int[] dx = { 1, -1, 0, 0 };
    static int[] dy = { 0, 0, 1, -1 };

    static void Main()
    {
        n = int.Parse(Console.ReadLine());
        map = new int[n, n];
        visited = new bool[n, n];

        for (int i = 0; i < n; i++)
        {
            string line = Console.ReadLine();
            for (int j = 0; j < n; j++)
            {
                map[i, j] = line[j] - '0';
            }
        }

        List results = new List();

        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                if (map[i, j] == 1 && !visited[i, j])
                {
                    results.Add(BFS(i, j));
                }
            }
        }

        results.Sort();
        Console.WriteLine(results.Count);
        foreach (int count in results)
        {
            Console.WriteLine(count);
        }
    }

    static int BFS(int startX, int startY)
    {
        Queue<(int, int)> queue = new Queue<(int, int)>();
        queue.Enqueue((startX, startY));
        visited[startX, startY] = true;

        int count = 0;

        while (queue.Count > 0)
        {
            var (x, y) = queue.Dequeue();
            count++;

            for (int i = 0; i < 4; i++)
            {
                int nx = x + dx[i];
                int ny = y + dy[i];

                if (nx >= 0 && ny >= 0 && nx < n && ny < n && map[nx, ny] == 1 && !visited[nx, ny])
                {
                    queue.Enqueue((nx, ny));
                    visited[nx, ny] = true;
                }
            }
        }

        return count;
    }
}

6. 코드 설명

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

  1. 입력으로 n을 받아 n × n 크기의 집 배치 정보를 2D 배열에 저장합니다.
  2. visited 배열을 통해 각 집의 방문 여부를 기록합니다.
  3. 중첩된 for 루프를 사용하여 모든 집을 탐색하되, 방문하지 않은 집에 대해서만 BFS를 실행합니다.
  4. BFS 메소드는 큐를 사용하여 시작점에서 연결된 집을 탐색하고, 연결된 집의 수를 셉니다.
  5. 모든 단지의 크기를 리스트에 저장하고, 정렬하여 출력합니다.

7. 결론

이번 강좌에서는 너비 우선 탐색(BFS)을 활용한 문제를 통해 코딩 테스트에서 어떻게 문제를 해결할 수 있는지 살펴보았습니다. BFS는 다양한 문제에 적용할 수 있는 강력한 도구입니다. 그래프를 탐색할 때, 최단 경로를 찾을 때 등의 상황에서 BFS의 이해는 아주 중요합니다.

계속해서 BFS에 대한 예제와 더 복잡한 문제를 풀어보며 실력을 쌓아 보세요. 질문이나 의견이 있으시면 언제든 댓글로 남겨주세요. 다음 시간에는 또 다른 알고리즘에 대해 다루도록 하겠습니다!

© 2023 코딩테스트 강좌. All rights reserved.

C# 코딩테스트 강좌, 줄 세우기

안녕하세요, 블로그 독자 여러분! 오늘은 C# 코딩테스트 강좌의 한 부분으로 줄 세우기 문제를 다루겠습니다. 이 문제는 간단해 보일 수 있지만, 알맞은 알고리즘을 사용하지 않으면 매우 복잡해질 수 있습니다. 또한 실제 취업의 코딩 테스트에서 자주 등장하는 문제 유형 중 하나입니다.

문제 설명

주어진 학생들의 키 정보를 통해 그들을 줄 세우는 문제입니다. 학생들은 키에 따라 오름차순으로 정렬되어야 하며, 같은 키를 가진 학생들은 서로의 순서를 유지해야 합니다. 즉, 정렬 시 안정성을 유지해야 합니다.

문제 정의

    주어진 학생들의 키를 배열로 받을 때, 배열을 오름차순으로 정렬해야 합니다.

    입력
    - 정수 N: 학생의 수 (1 ≤ N ≤ 100,000)
    - 정수 배열 heights: 학생들의 키 (1 ≤ heights[i] ≤ 200 cm)

    출력
    - 정렬된 학생들의 키를 반환해야 합니다.
    

예제 입력 및 출력

    입력: [160, 155, 170, 160, 175]
    출력: [155, 160, 160, 170, 175]
    

문제 해결 전략

문제에 대한 해결 전략을 세우는 것은 중요합니다. 학생들의 키를 정렬해야 하므로, 효율적인 정렬 알고리즘을 적용해야 합니다. 여러 가지 정렬 알고리즘 중에서, 병합 정렬(Merge Sort)이나 퀵 정렬(Quick Sort) 같은 O(N log N) 시간 복잡도를 가진 알고리즘을 쓸 수 있습니다.

1. 병합 정렬 설명

병합 정렬은 분할 정복 알고리즘으로, 배열을 두 개의 하위 배열로 나누고 각각을 정렬한 후, 정렬된 하위 배열을 병합하여 최종적으로 정렬된 배열을 만드는 방식입니다. 이 방식은 안정적이며, 정렬된 배열이 필요할 때 유용합니다.

2. 퀵 정렬 설명

퀵 정렬 역시 분할 정복 알고리즘입니다. 피벗을 기준으로 두 개의 부분 배열로 나누고, 재귀적으로 정렬합니다. 평균 시간 복잡도는 O(N log N)이지만, 최악의 경우 O(N^2)가 될 수 있습니다. 하지만 적절한 피벗 선택을 통해 성능을 개선할 수 있습니다.

C# 코드 구현

이번 섹션에서는 C# 언어로 해당 문제를 해결하는 코드를 작성해보겠습니다. 아래는 병합 정렬을 사용해 학생들의 키를 정렬하는 코드입니다.


using System;

class Sort
{
    public static void MergeSort(int[] heights, int left, int right)
    {
        if (left < right)
        {
            int mid = (left + right) / 2;
            MergeSort(heights, left, mid);
            MergeSort(heights, mid + 1, right);
            Merge(heights, left, mid, right);
        }
    }

    public static void Merge(int[] heights, int left, int mid, int right)
    {
        int n1 = mid - left + 1;
        int n2 = right - mid;

        int[] leftArray = new int[n1];
        int[] rightArray = new int[n2];

        for (int i = 0; i < n1; i++)
            leftArray[i] = heights[left + i];
        for (int j = 0; j < n2; j++)
            rightArray[j] = heights[mid + 1 + j];

        int k = left;
        int iIndex = 0, jIndex = 0;

        while (iIndex < n1 && jIndex < n2)
        {
            if (leftArray[iIndex] <= rightArray[jIndex])
            {
                heights[k] = leftArray[iIndex];
                iIndex++;
            }
            else
            {
                heights[k] = rightArray[jIndex];
                jIndex++;
            }
            k++;
        }

        while (iIndex < n1)
        {
            heights[k] = leftArray[iIndex];
            iIndex++;
            k++;
        }

        while (jIndex < n2)
        {
            heights[k] = rightArray[jIndex];
            jIndex++;
            k++;
        }
    }

    static void Main(string[] args)
    {
        int[] heights = { 160, 155, 170, 160, 175 };
        MergeSort(heights, 0, heights.Length - 1);

        Console.WriteLine("정렬된 키: " + string.Join(", ", heights));
    }
}
    

코드 설명

위 코드는 병합 정렬 알고리즘을 이용하여 주어진 배열을 정렬하는 예시입니다. MergeSort 메소드는 재귀적으로 배열을 분할하고, Merge 메소드는 두 하위 배열을 병합하여 정렬합니다.

코드 흐름

  • MergeSort 메소드: 배열을 재귀적으로 반으로 나누어 정렬합니다.
  • Merge 메소드: 두 개의 정렬된 하위 배열을 하나로 병합하여 정렬된 배열을 만듭니다.
  • Main 메소드: 프로그램의 시작점으로, 예시 배열을 정의하고 정렬 후 결과를 출력합니다.

성능 분석

병합 정렬의 시간 복잡도는 O(N log N)이며, 최악의 경우에도 동일한 복잡도를 가집니다. 공간 복잡도는 O(N)입니다. 이 점은 큰 데이터셋을 처리할 때 유리합니다. 정렬이 안정적(stable)하기 때문에, 예를 들어 키가 같은 경우 원래의 순서를 보장할 수 있습니다.

이 문제의 응용

줄 세우기 문제는 여러 분야에 응용될 수 있습니다. 예를 들어, 대기열 관리, 학생 성과 분석 등 다양한 상황에서 유용하게 쓰일 수 있습니다. 이 문제를 해결하면서 다른 데이터 정렬 문제로 확장할 수 있는 가능성을 고려해보면 좋겠습니다.

결론

이번 포스트에서는 C#을 사용하여 줄 세우기 문제를 해결하는 방법을 알아보았습니다. 문제를 정의하고, 이를 해결하기 위한 알고리즘과 코드를 구현하는 과정을 통해 알고리즘 사고를 키워나갈 수 있습니다. 다양한 문제를 통해 알고리즘적 사고를 발전시키는 것이 중요합니다.

다음 시간에는 또 다른 유형의 알고리즘 문제를 다뤄보도록 하겠습니다. 질문이나 피드백은 댓글로 남겨주세요. 고맙습니다!

C# 코딩테스트 강좌, 가장 큰 정사각형 찾기

1. 문제 설명

이 문제는 주어진 이진 행렬(matrix) 내에서 가장 큰 크기의 단일 정사각형을 찾아 그 크기를 반환하는 문제입니다.
이진 행렬은 각각의 요소가 0 또는 1로 구성되어 있습니다.
1로 구성된 정사각형의 가장 큰 크기를 찾아야 하며, 크기는 정사각형의 변의 길이로 정의됩니다.

예시

  • 입력: matrix = [[0,1,1,1,0],[0,1,1,1,1],[0,1,1,1,1],[0,0,0,0,0]]
  • 출력: 3 (가장 큰 정사각형의 변의 길이)

2. 문제 해결 접근법

이 문제를 해결하기 위해서는 동적 프로그래밍(Dynamic Programming) 기법을 사용할 수 있습니다.
기본 아이디어는 각 위치에서 그 위치를 기준으로 왼쪽, 위, 대각선 위 위치의 정보(최소 크기)를 이용하여
현재의 위치에서 만들 수 있는 정사각형의 크기를 결정하는 것입니다.

2.1 상태 정의

dp[i][j]를 i행 j열에서 만들 수 있는 정사각형의 최대 크기로 정의합니다.
즉, dp[i][j] 값은 matrix[i][j]가 1일 경우,
dp[i-1][j], dp[i][j-1], dp[i-1][j-1] 중 최소값에 1을 더한 값으로 설정합니다.
만약 matrix[i][j]가 0이라면, dp[i][j]는 0이 됩니다.

2.2 점화식

dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1 (단, matrix[i][j] == 1일 경우)

2.3 초기 조건

첫 번째 행과 첫 번째 열의 경우, matrix[i][j] 값이 1이면 dp[i][j]도 1,
0이면 0으로 초기화합니다.

3. 알고리즘 구현

다음은 위의 접근법을 기반으로 한 C# 코드입니다.

C#
public class Solution {
    public int MaximalSquare(char[][] matrix) {
        if (matrix.Length == 0) return 0;
        
        int maxSide = 0;
        int rows = matrix.Length;
        int cols = matrix[0].Length;
        int[][] dp = new int[rows][];
        
        for (int i = 0; i < rows; i++) {
            dp[i] = new int[cols];
        }

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                if (matrix[i][j] == '1') {
                    if (i == 0 || j == 0) {
                        dp[i][j] = 1; // 가장자리의 경우 직접 1로 설정
                    } else {
                        dp[i][j] = Math.Min(Math.Min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]) + 1;
                    }
                    maxSide = Math.Max(maxSide, dp[i][j]); // 최대 크기 업데이트
                }
            }
        }
        
        return maxSide * maxSide; // 정사각형의 넓이를 반환
    }
}

4. 복잡도 분석

이 알고리즘의 시간복잡도는 O(m * n)입니다. 여기서 m은 행렬의 행 수, n은 열 수입니다.
각 요소를 한 번씩만 확인하기 때문에 이와 같은 복잡도가 나타납니다.
공간복잡도 또한 동적 배열을 이용하기 때문에 O(m * n)으로 동일합니다.

5. 결론

이 문제는 동적 프로그래밍의 강력한 활용 예를 보여줍니다.
이진 행렬에서 정사각형을 찾는 이 문제를 통하여, 동적 프로그래밍의 사고방식과 알고리즘을 올바르게 설계하는 방법을 배울 수 있었습니다.
C#에서 이러한 문제를 해결하는 방식에 대해 충분한 이해를 돕는 것이 중요합니다.

6. 추가적인 학습 자료

C# 코딩테스트 강좌, ‘좋은 수’ 구하기

문제 설명

“좋은 수”란 주어진 수 N의 모든 약수 중에서 홀수인 약수를 의미합니다. 여러분의
목표는 주어진 수 N이 있을 때, N의 모든 홀수 약수를 찾아내는 것입니다.
예를 들어, N이 12라면, 이 수의 약수는 1, 2, 3, 4, 6, 12이며,
그 중 홀수 약수는 1과 3입니다. 이 문제에서 주어진 수의 홀수 약수를 오름차순으로 정렬하여 출력하는 프로그램을 작성하세요.

입력 형식

입력은 정수 N(1 ≤ N ≤ 10^6)입니다.

출력 형식

N의 홀수 약수를 오름차순으로 한 줄에 출력합니다.
홀수 약수가 없는 경우 “홀수 약수가 없습니다.” 라고 출력합니다.

예시 입력 및 출력

    입력:
    12
    출력:
    1 3
    
    입력:
    7
    출력:
    1 7
    

문제 풀이

단계 1: 문제 이해하기

문제를 해결하기 위해서는 먼저 주어진 수 N의 약수를 정확히 정의할 필요가 있습니다.
약수는 어떤 수를 나누었을 때 나머지가 0이 되는 수를 의미합니다.
예를 들어 N이 12일 때, 약수는 12를 나눌 수 있는 모든 수입니다.

단계 2: 약수를 찾는 방법

N의 모든 약수를 찾기 위해서는 1부터 N까지 반복하면서, N을 현재의 수로 나누어
나머지가 0인지 확인하면 됩니다.

방법:
– 1부터 N까지의 모든 정수를 반복합니다.
– 현재의 수 i로 N을 나누었을 때 나머지가 0이라면 i는 N의 약수입니다.
– 추가로, i가 홀수인지도 체크해야 하므로, 홀수일 경우에만 리스트에 저장합니다.

단계 3: 홀수 약수 저장 및 출력

홀수 약수를 저장하는 리스트를 만든 후, 이 리스트를 오름차순으로 정렬하고 출력합니다.
만약 리스트가 비어있다면 “홀수 약수가 없습니다.”라는 메시지를 출력하도록 합니다.

단계 4: C# 코드 구현

    
    using System;
    using System.Collections.Generic;

    class Program
    {
        static void Main()
        {
            int N = int.Parse(Console.ReadLine());
            List oddDivisors = new List();

            for (int i = 1; i <= N; i++)
            {
                if (N % i == 0 && i % 2 != 0)
                {
                    oddDivisors.Add(i);
                }
            }

            if (oddDivisors.Count == 0)
            {
                Console.WriteLine("홀수 약수가 없습니다.");
            }
            else
            {
                oddDivisors.Sort();
                Console.WriteLine(string.Join(" ", oddDivisors));
            }
        }
    }
    
    

코드 설명

1. 입력 받기

<code>int N = int.Parse(Console.ReadLine());</code>
부분은 사용자로부터 정수 N을 입력받는 부분입니다. Console.ReadLine() 메서드는
사용자가 입력한 값을 문자열로 읽어온 후, int.Parse() 메서드를 통해 정수로 변환합니다.

2. 홀수 약수 찾기

<code>for (int i = 1; i <= N; i++)</code>부터 시작하여, 1부터 N까지
반복문을 실행합니다. 그리고 <code>if (N % i == 0 && i % 2 != 0)</code> 구문을 통해
N이 i로 나누어떨어지면서, i가 홀수인지 체크합니다. 두 조건을 만족하면, i를
홀수 약수 리스트에 추가합니다.

3. 결과 출력

마지막으로 홀수 약수 리스트의 길이를 체크하여, 약수가 없으면 “홀수 약수가 없습니다.”라고
출력하고, 약수가 있을 경우 오름차순으로 정렬한 후 리스트를 공백으로 구분하여 출력합니다.
여기서 <code>string.Join(” “, oddDivisors)</code> 구문은 리스트의 값을 문자열로
변환하여 출력합니다.

성능 분석

위 알고리즘의 시간 복잡도는 O(N)입니다. 이는 N이 최대 10^6이므로, 느리게 느껴질 수 있습니다.
그러나 주어진 입력값의 범위를 고려했을 때, 일반적으로는 충분히 빠르게 계산되는 편입니다.
추가적으로 성능을 개선하기 위한 방법으로는 약수를 찾는 범위를 N의 제곱근으로 줄이는 것이 있습니다.
이렇게 하면 시간 복잡도를 O(√N)으로 감소시킬 수 있습니다.

더 나아가기: N의 홀수 약수 구하기 최적화

    
    using System;
    using System.Collections.Generic;

    class Program
    {
        static void Main()
        {
            int N = int.Parse(Console.ReadLine());
            List oddDivisors = new List();

            for (int i = 1; i * i <= N; i++)
            {
                if (N % i == 0)
                {
                    if (i % 2 != 0)
                    {
                        oddDivisors.Add(i);
                    }

                    int pairedDivisor = N / i;
                    if (pairedDivisor != i && pairedDivisor % 2 != 0)
                    {
                        oddDivisors.Add(pairedDivisor);
                    }
                }
            }

            if (oddDivisors.Count == 0)
            {
                Console.WriteLine("홀수 약수가 없습니다.");
            }
            else
            {
                oddDivisors.Sort();
                Console.WriteLine(string.Join(" ", oddDivisors));
            }
        }
    }
    
    

이 코드에서는 1부터 N의 제곱근까지 반복하면서 각 i에 대해 i와 N/i 쌍의 약수를
동시에 검사하게 됩니다. 이렇게 하면 효율성을 높일 수 있습니다.

마무리

본 글에서는 C#을 이용하여 주어진 정수 N의 홀수 약수를 찾는
알고리즘 문제를 풀어보았습니다. 문제 풀이 과정은 단계별로 세분화하여 설명하였고,
최적화를 통한 코드 개선 방법도 제시하였습니다. 이러한 과정은 코딩 테스트나 알고리즘
스킬을 향상시키는 데에 도움이 될 것입니다.

작성자: 조광형

날짜: [날짜 입력]