[CH02/01] solution

๊น€์—ฌ์šธยท2025๋…„ 6์›” 10์ผ

๋‚ด์ผ๋ฐฐ์›€์บ ํ”„

๋ชฉ๋ก ๋ณด๊ธฐ
18/139

[CH02/01] ๊ฐ„๋‹จํ•œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ตฌํ˜„

๐Ÿ“Ž[CH2/01] ๊ฐ„๋‹จํ•œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ตฌํ˜„
๐Ÿ“Ž[Notion] ๊ฐ„๋‹จํ•œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ตฌํ˜„
ํ•„์ˆ˜ ๊ธฐ๋Šฅ๋งŒ ๊ตฌํ˜„ํ–ˆ์–ด์„œ ํ’€์ด ๊ฐ•์˜๋ฅผ ๋ณด๋ฉด์„œ ๋„์ „ ๊ธฐ๋Šฅ์„ ๊ณต๋ถ€ํ–ˆ๋‹ค.

์š”๊ตฌ์‚ฌํ•ญ (๋„์ „ ๊ธฐ๋Šฅ)

์‚ฌ์šฉ์ž๊ฐ€ ์ž…๋ ฅํ•œ ์ˆซ์ž ๋ฐฐ์—ด์„ ์ •๋ ฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๊ตฌํ˜„ํ•ด๋ณด์„ธ์š”.

  • ์ •๋ ฌ์€ ์˜ค๋ฆ„์ฐจ์ˆœ ์ •๋ ฌ๊ณผ ๋‚ด๋ฆผ์ฐจ์ˆœ ์ •๋ ฌ์ด ๊ฐ€๋Šฅํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.
  • ์ˆซ์ž 1์„ ์ž…๋ ฅ ๋ฐ›์œผ๋ฉด ์˜ค๋ฆ„์ฐจ์ˆœ ์ •๋ ฌ, ์ˆซ์ž 2๋ฅผ ์ž…๋ ฅ ๋ฐ›์œผ๋ฉด ๋‚ด๋ฆผ์ฐจ์ˆœ ์ •๋ ฌ์„ ํ•˜๋„๋ก ๊ตฌํ˜„ํ•ด์ฃผ์„ธ์š”.
  • algorithm ํ—ค๋”์˜ sort ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜์ง€ ์•Š๊ณ  ์ง์ ‘ ๊ตฌํ˜„ํ•ด๋ณด์„ธ์š”.
  • ์˜ค๋ฆ„์ฐจ์ˆœ ์ •๋ ฌ๊ณผ ๋‚ด๋ฆผ์ฐจ์ˆœ ์ •๋ ฌ ๋™์ž‘์„ ๊ฐ๊ฐ ํ•จ์ˆ˜๋กœ ๊ตฌํ˜„ํ•ด๋ณด์„ธ์š”.


์ฝ”๋“œ

#include <iostream>
using namespace std;

// ๋งค๊ฐœ๋ณ€์ˆ˜(ํŒŒ๋ผ๋ฏธํ„ฐ)๋กœ ๋ฐฐ์—ด์„ ๋ฐ›๋Š” ํ•จ์ˆ˜ ์„ ์–ธ
void printArray(int numbers[], int size)
{
    for (int i = 0; i < size; i++)
    {
        cout << numbers[i] << " ";
    }
    cout << endl;  // ์ถœ๋ ฅ ํ›„ ์ค„๋ฐ”๊ฟˆ
}

// ํ•ฉ๊ณ„๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ํ•จ์ˆ˜
int getSum(int numbers[], int size)
{
    int sum = 0;  // ํ•ฉ๊ณ„๋ฅผ ๋‹ด์„ ๋ณ€์ˆ˜ ์„ ์–ธ ๋ฐ ์ดˆ๊ธฐํ™”

    // ๋ฐฐ์—ด์„ ๋Œ๋ฉด์„œ ํ•ฉ๊ณ„ ๊ตฌํ•˜๊ธฐ
    for (int i = 0; i < size; i++)  // ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๋งŒํผ ๋ฐ˜๋ณต
    {
        sum += numbers[i];  // ๋ฐฐ์—ด์˜ ๊ฐ ์š”์†Œ๋ฅผ ํ•ฉ์‚ฐ
    }

    return sum;  // ํ•ฉ๊ณ„ ๋ฐ˜ํ™˜
}

// ํ‰๊ท ์„ ๋ฐ˜ํ™˜ํ•˜๋Š” ํ•จ์ˆ˜
double getAverage(int numbers[], int size)
{
    // ํ‰๊ท  == ์ดํ•ฉ / ๊ฐœ์ˆ˜
    // ์ •์ˆ˜ / ์ •์ˆ˜ == ์ •์ˆ˜ -> ํ•˜๋‚˜๋ฅผ ์‹ค์ˆ˜ํ˜•์œผ๋กœ ํ˜•๋ณ€ํ™˜
    return getSum(numbers, size) / static_cast<double>(size);
    // return static_cast<double>)(getSum(numbers, size)) / size;
}

// ๋ฒ„๋ธ”์ •๋ ฌ ํ•จ์ˆ˜ (์˜ค๋ฆ„์ฐจ์ˆœ)
void sortAsc(int numbers[], int size)
{   
    // ๋’ค์—๊ฐ€ ์ •๋ ฌ๋˜๋ฉด ๋งˆ์ง€๋ง‰ ํšŒ์ „์—์„œ ๊ฐ€์žฅ ์•ž ์ˆซ์ž๋Š” ์ด๋ฏธ ์ œ์ผ ์ž‘์€ ์ˆ˜๋ผ ์ •๋ ฌ ์•ˆ ํ•ด๋„ ๋จ
    for (int i = 0; i < size - 1; i++)   // i๋Š” ํ–‰ ํšŒ์ „
    {
        for (int j = 0; j < size - 1 - i; j++)  // j๋Š” ์—ด ํšŒ์ „
        {
            if (numbers[j] > numbers[j + 1])
            {
                // Swap
                int temp = numbers[j];
                numbers[j] = numbers[j + 1];
                numbers[j + 1] = temp;
            }
        }
    }
}

// ๋ฒ„๋ธ” ์ •๋ ฌ ํ•จ์ˆ˜ (๋‚ด๋ฆผ์ฐจ์ˆœ)
void sortDesc(int numbers[], int size)
{
    for (int i = 0; i < size - 1; i++)
    {
        for (int j = 0; j < size - 1 - i; j++)
        {
            if (numbers[j] < numbers[j + 1])
            {
                // Swap
                int temp = numbers[j];
                numbers[j] = numbers[j + 1];
                numbers[j + 1] = temp;
            }
        }
    }
}

int main()
{
    // ์‚ฌ์šฉ์ž๋กœ๋ถ€ํ„ฐ ์ •์ˆ˜ 5๊ฐœ๋ฅผ ์ž…๋ ฅ๋ฐ›์•„ ๋ฐฐ์—ด์— ์ €์žฅ
    const int SIZE = 5;  // ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๋ฅผ 5๋กœ ๊ณ ์ •
    int numbers[SIZE] = {};  // ๋ฐฐ์—ด ์ƒ์„ฑ ๋ฐ ์ดˆ๊ธฐํ™”

    int sortChoice = 0;

    // 5๋ฒˆ ๋Œ๋ฉด์„œ ์‚ฌ์šฉ์ž์—๊ฒŒ ์ •์ˆ˜๊ฐ’์„ ์ž…๋ ฅ ๋ฐ›์Œ
    for (int i = 0; i < SIZE; i++)
    {
        cout << i + 1 << "๋ฒˆ์งธ ์ˆซ์ž ์ž…๋ ฅ: ";
        cin >> numbers[i];
    }

    printArray(numbers, SIZE);  // ํ•จ์ˆ˜์— ๋ฐฐ์—ด์˜ ์ฃผ์†Œ์™€ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๋ฅผ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ๋„˜๊น€
    
    cout << "์ดํ•ฉ: " << getSum(numbers, SIZE) << endl;
    cout << "ํ‰๊ท : " << getAverage(numbers, SIZE) << endl;

    cout << "์˜ค๋ฆ„์ฐจ์ˆœ: 1๋ฒˆ, ๋‚ด๋ฆผ์ฐจ์ˆœ: 2๋ฒˆ";
    cin >> sortChoice;

    if (sortChoice == 1)
    {
        sortAsc(numbers, SIZE);     // sortAsc()๋Š” ์ •๋ ฌ๋งŒ ์ˆ˜ํ–‰, return ๊ฐ’ ์—†์Œ
    }
    else if (sortChoice == 2)
    {
        sortDesc(numbers, SIZE);
    }
    else
    {
        cout << "1๋ฒˆ, 2๋ฒˆ ์ค‘์— ์„ ํƒํ•˜์„ธ์š”." << endl;
    }
   
    // ์ •๋ ฌ ํ•จ์ˆ˜๋“ค์€ ์ •๋ ฌ๋งŒ ์ˆ˜ํ–‰, return ๊ฐ’ ์—†์Œ 
    // ์—ฌ๊ธฐ์„œ ์ถœ๋ ฅ
    printArray(numbers, SIZE);  
   
    return 0;

}


๊ตฌํ˜„ ๊ธฐ๋Šฅ ์ •๋ฆฌ

SIZE์™€ size์˜ ์ฐจ์ด

  • SIZE๋Š” ๋ฐฐ์—ด ํฌ๊ธฐ์ฒ˜๋Ÿผ ๋ณ€ํ•˜์ง€ ์•Š๋Š” ๊ฐ’์„ ํ‘œํ˜„ํ•  ๋•Œ ๋Œ€๋ฌธ์ž๋กœ ์‚ฌ์šฉํ•ด ์ƒ์ˆ˜(constant)์ž„์„ ํ‘œ์‹œํ•œ๋‹ค.
  • size๋Š” ๋ณ€์ˆ˜(variable)์ด๋ฉฐ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๋‚˜ ๋‹ค๋ฅธ ํฌ๊ธฐ ๊ฐ’์„ ๋‹ด๋Š” ๋ฐ ์‚ฌ์šฉ๋œ๋‹ค. ๋ณ€์ˆ˜๋Š” ๊ฐ’์ด ๋ฐ”๋€” ์ˆ˜ ์žˆ๋‹ค.
  • ๋ฐฐ์—ด ํฌ๊ธฐ์™€ ๊ฐ™์€ ๊ณ ์ •๋œ ๊ฐ’ โ†’ ๋Œ€๋ฌธ์ž
    ๊ฐ€๋ณ€์ ์ธ ๊ฐ’ โ†’ ์†Œ๋ฌธ์ž

ํ•จ์ˆ˜์—์„œ size๋ฅผ ๋ฐ›๋Š” ์ด์œ 

  • SIZE๋Š” main ํ•จ์ˆ˜ ๋‚ด์˜ ์ƒ์ˆ˜์ด๋ฏ€๋กœ printArray๋‚˜ ๋‹ค๋ฅธ ํ•จ์ˆ˜์—์„œ ์ง์ ‘ ์‚ฌ์šฉํ•  ์ˆ˜ ์—†๋‹ค.
  • ๊ทธ๋ž˜์„œ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๋ฅผ size๋ผ๋Š” ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ „๋‹ฌํ•˜๋Š” ๋ฐฉ์‹์œผ๋กœ ํ•ด๊ฒฐ
  • ๋งค๊ฐœ๋ณ€์ˆ˜ ์ด๋ฆ„์€ ๋‹ค๋ฅด๊ฒŒ ํ•  ์ˆ˜ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ์ƒ์ˆ˜ SIZE์™€ ๋‹ค๋ฅด๊ฒŒ size๋กœ ํ•  ์ˆ˜ ์žˆ๋‹ค. ์ค‘์š”ํ•œ ๊ฑด ํ•จ์ˆ˜ ํ˜ธ์ถœ ์‹œ SIZE์˜ ๊ฐ’(5)์„ size๋กœ ์ „๋‹ฌํ•˜๋Š” ๊ฒƒ!

printArray ํ•จ์ˆ˜์™€ for ๋ฐ˜๋ณต๋ฌธ

  • printArray ํ•จ์ˆ˜ ์•ˆ์˜ for ๋ฐ˜๋ณต๋ฌธ์€ ๋ฐฐ์—ด์˜ ๊ฐ ์š”์†Œ๋ฅผ ํ•˜๋‚˜์”ฉ ์ถœ๋ ฅํ•˜๋Š” ์—ญํ• ์„ ํ•œ๋‹ค.

  • ๋ฐฐ์—ด ํฌ๊ธฐ๋งŒํผ ๋ฐ˜๋ณตํ•˜๋ฉด์„œ ๋ฐฐ์—ด์˜ ๊ฐ ์ธ๋ฑ์Šค๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

    void printArray(int numbers[], int size)
    {
       for (int i = 0; i < size; i++)
       {
           cout << numbers[i] << " ";  // ๋ฐฐ์—ด์˜ ๊ฐ ์š”์†Œ ์ถœ๋ ฅ
       }
       cout << endl;
    }
    

์ •๋ ฌ ํ•จ์ˆ˜์˜ ๋™์ž‘ (๋ฒ„๋ธ” ์ •๋ ฌ)

  • sortAsc()์™€ sortDesc()๋Š” ๋ฐฐ์—ด์„ ์ •๋ ฌ๋งŒ ์ˆ˜ํ–‰ํ•˜๊ณ  ๋ฆฌํ„ด ๊ฐ’์ด ์—†๋‹ค.
    // ๋ฆฌํ„ด ๊ฐ’์ด ์—†์–ด์„œ ์ถœ๋ ฅ ์•ˆ ๋จ
    cout << "์˜ค๋ฆ„์ฐจ์ˆœ: "" << sortAsc << endl;  
  • sortAsc / sortDesc ํ•จ์ˆ˜๋Š” ๋ฐฐ์—ด์˜ ๊ฐ’์„ ์ง์ ‘ ์ˆ˜์ •ํ•ด ์ •๋ ฌํ•˜๋Š” ๊ฒƒ๋งŒ ์ˆ˜ํ–‰ํ•ด ์ถœ๋ ฅ์€ printArray๋ฅผ ํ†ตํ•ด ์ด๋ฃจ์–ด์ง„๋‹ค.

๋ณ€์ˆ˜ ์ดˆ๊ธฐํ™” ์œ„์น˜์™€ ์‹œ์ 

  • sortChoice ๋ณ€์ˆ˜๋Š” ๋ฉ”์ธ ํ•จ์ˆ˜ ๋‚ด์—์„œ ์„ ์–ธ๊ณผ ๋™์‹œ์— ์ดˆ๊ธฐํ™” ๊ฐ€๋Šฅํ•˜๋‹ค.
  • ๋ณดํ†ต ๋ณ€์ˆ˜์˜ ์ดˆ๊ธฐํ™”๋Š” ์‚ฌ์šฉ์ž ์ž…๋ ฅ์„ ๋ฐ›๊ธฐ ์ „์— ํ•จ

0๊ฐœ์˜ ๋Œ“๊ธ€