최대값, 최소값 찾기

사용자로부터 일련의 숫자 5개를 입력받아, 그 중에서 최대값과 최소값을 찾는 프로그램 작성하시오.

 

<나의 풀이 과정>

int[] num = new int[5]; // 사용자에게 입력 받을 배열 초기화

int max = num[0]; // 초기화
int min = num[0]; // 초기화

for (int i = 0; i < 5; i++) // 0~4 인덱스 안의 숫자 비교
{
    Console.Write("숫자를 입력하세요: ");
    num[i] = int.Parse(Console.ReadLine()); // 사용자에게 입력 받기

    if (num[i] > max) // num[i]가 max보다 크다면
    {
        max = num[i];
    }
    if (num[i] < min) // num[i]가 min보다 작다면
    {
        min = num[i];
    }
}
Console.WriteLine("최대값: " + max);
Console.WriteLine("최소값: " + min);

초기화가 min이 초기화 된 상태인 0의 값으로 비교되므로 늘 최소값이 0으로 나오게 된다.

 

int[] num = new int[5];

for (int i = 0; i < 5; i++)
{
    Console.Write("숫자를 입력하세요: ");
    num[i] = int.Parse(Console.ReadLine());
}

int max = num[0];
int min = num[0];

for (int i = 0;i < 5; i++) 
{
    if (num[i] > max)
    {
        max = num[i];
    }
    if (num[i] < min)
    {
        min = num[i];
    }
}
Console.WriteLine("최대값: " + max);
Console.WriteLine("최소값: " + min);

사용자가 입력한 숫자를 for문을 통해 5회 반복하여 배열에 넣어준 뒤, 또다시 for문을 통해 5개의 숫자를 비교한다.

 

 

소수 판별하기

주어진 숫자가 소수인지 판별하는 함수와 코드를 만드시오.

 

<나의 풀이 과정>

// 주어진 숫자가 소수인지 판별하는 함수
static bool IsPrime(int num)
{
    if (num <= 1) // 1보다 작거나 같으면 소수가 아니다
    {
        return false;
    }
    for (int i = 2; i < num; i++) // 2보다 크고 자기 자신과 같은 숫자가 되기 전까지 1씩 증가
    {
        if (num % i == 0) // 나누어 떨어지면 소수가 아니다
        {
            return false;
        }
    }

    return true; // 소수
}

static void Main()
{
    Console.Write("숫자를 입력하세요: "); // 사용자에게 숫자 입력 요청
    int num = int.Parse(Console.ReadLine()); // 사용자가 입력한 값을 정수로 변환하여 저장

    if (IsPrime(num)) // 입력 받은 숫자가 소수라면
    {
        Console.WriteLine(num + "은 소수입니다."); // 소수임을 출력
    }
    else // 소수가 아니라면
    {
        Console.WriteLine(num + "은 소수가 아닙니다."); // 소수가 아님을 출력
    }
}

이렇게 하면 작은 수일 때는 괜찮지만 큰 수를 입력했을 때 메모리를 많이 잡아먹게 된다.

static bool IsPrime(int num)
{
    if (num <= 1)
    {
        return false;
    }
    for (int i = 2; i <= num / 2; i++) // 2부터 자기 자신의 절반까지만 확인
    {
        if (num % i == 0)
        {
            return false;
        }
    }

    return true;
}

약수는 자기 자신을 제외하면 절반까지가 최대이기 때문에 2로 나눠주면 메모리 사용량을 줄일 수 있다. 그러나 49, 81 등 제곱된 수의 약수는 절반까지 도달하지 않아도 소수가 아님을 확인 할 수 있다.

 

static bool IsPrime(int num)
{
    if (num <= 1)
    {
        return false;
    }
    for (int i = 2; i * i <= num; i++) // 2부터 숫자의 제곱근까지만 확인
    {
        if (num % i == 0)
        {
            return false;
        }
    }

    return true;
}

 

 

 

숫자 맞추기

컴퓨터는 1에서 100까지의 숫자를 임의로 선택하고, 사용자는 이 숫자를 맞춘다. 사용자가 입력한 숫자가 컴퓨터의 숫자보다 크면 "너무 큽니다!"라고 알려주고, 작으면 "너무 작습니다!"라고 알려준다. 사용자가 숫자를 맞출 시, 게임 종료.

 

Random random = new Random();
int numberToGuess = random.Next(1, 101);
int userNum = 0;
int numberTry = 0;
bool playAgain = true;

Console.WriteLine("숫자 맞추기 게임을 시작합니다. 1에서 100까지의 숫자 중 하나를 맞춰보세요.");
while (playAgain)
{
    while (numberToGuess != userNum)
    {
        Console.Write("숫자를 입력하세요: ");
        userNum = Convert.ToInt32(Console.ReadLine());

        if (numberToGuess > userNum)
        {
            Console.WriteLine("너무 작습니다!");
        }
        else if (numberToGuess < userNum)
        {
            Console.WriteLine("너무 큽니다!");
        }
        numberTry++;
    }
    Console.WriteLine("축하합니다! {0}번 만에 숫자를 맞추었습니다.", numberTry);
    playAgain = false;
}

 

 

틱택토(콘솔)

 

<나의 풀이 과정>

 

메서드

중복되는 코드를 뭉쳐놓은 하나의 블록. 코드를 재사용하거나 모듈화 할 수 있게 만들어주는 것.

  • 코드의 재사용성
  • 모듈화
  • 가독성과 유지보수성
  • 중복 제거
  • 추상화

 

메서드의 구조

[접근 제한자] [리턴 타입] [메서드 이름]([매개변수])
{
    // 메서드 실행 코드
}
  • 접근 제한자(Access Modifier): 메서드에 접근할 수 있는 범위 지정. (public, private, protected 등)
  • 리턴 타입(Return Type): 메서드가 반환하는 값의 데이터 타입 지정. (반환 값이 없을 경우 void 사용)
  • 메서드 이름(Method Name): 메서드를 호출할 때 사용하는 이름.
  • 매개변수(Parameters): 메서드에 전달되는 입력 값. 0개 이상의 매개변수를 정의할 수 있다.
  • 메서드 실행에 코드(Method Body): 중괄호({}) 안에 메서드가 수행하는 작업을 구현하는 코드 작성.

 

매개변수와 반환값

static void PrintLine()
{
    for (int i = 0; i < 10; i++)
    {
        Console.Write("=");
    }
    Console.WriteLine();
}

static void PrintLine2(int count)
{
    for (int i = 0; i < count; i++)
    {
        Console.Write("=");
    }
    Console.WriteLine();
}

static int Add(int a, int b)
{
    return a + b;
}

static void Main(string[] args)
{
    // 사용 예시
    PrintLine();
    PrintLine2(20);

    int result = Add(10, 20);
    Console.WriteLine(result);
}

 

 

오버로딩

매개변수 목록이 다중 정의된 것. 매개변수의 개수, 타입, 순서가 다르면 다른 메서드로 취급한다. 메서드의 기능이나 작업은 동일하지만 입력값에 따라 다르게 동작해야 할 때 사용된다.

 

// 오버로딩
static int AddNumbers(int a, int b)
{
    return a + b;
}

static float AddNumbers(float a, float b)
{
    return a + b;
}

static int AddNumbers(int a, int b, int c)
{
    return a + b + c;
}


static void Main(string[] args)
{
    // 오버로딩 메서드 호출
    int sum1 = AddNumbers(10, 20);  // 두 개의 정수 매개변수를 가진 메서드 호출
    float sum3 = AddNumbers(10, 20); // 두 개의 실수 매개변수를 가진 메서드 호출
    int sum2 = AddNumbers(10, 20, 30);  // 세 개의 정수 매개변수를 가진 메서드 호출

 

 

재귀 호출

메서드가 자기 자신을 호출하는 것. 호출 스택에 호출된 메서드의 정보를 순차적으로 쌓고, 메서드가 반환되면서 스택에서 순차적으로 제거되는 방식이다. 메모리 사용량이 더 크고 실행 속도가 느릴 수 있으며,  무한 루프에 빠질 수 있기 때문에 주의해야한다.

 

// 재귀 호출
static void CountDown(int n)
{
    if (n <= 0)
    {
        Console.WriteLine("Done");
    }
    else
    {
        Console.WriteLine(n);
        CountDown(n - 1);  // 자기 자신을 호출
    }
}

static void Main(string[] args)
{
    // 재귀 호출
    CountDown(5);
}

 

 

구조체

여러 개의 데이터를 묶어서 하나의 사용자 정의 형식으로 만들기 위한 방법. 값 형식(대입하거나 값을 할당할 때 복사되는 것)으로 분류되며 struct 키워드를 사용하여 선언한다.

*자세한 내용은 class와 비교하며 언급

 

 

배열

 

// 배열
int[] array1 = new int[5];       // 크기가 5인 int형 배열 선언
string[] array2 = new string[3]; // 크기가 3인 string형 배열 선언
int num = 0;

array1[0] = 1; // 배열 초기화 - 보통 for문 등 반복문 사용
array1[1] = 2;
array1[2] = 3;
array1[3] = 4;
array1[4] = 5;

// 배열 예제
num = array1[0];

int[] itemPrices = { 100, 200, 300, 400, 500 };
int totalPrice = 0;

for (int i = 0; i < itemPrices.Length; i++)
{
    totalPrice += itemPrices[i];
}

Console.WriteLine("총 아이템 가격: " + totalPrice + " gold");

 

배열 예제

// 게임캐릭터 능력치 만들기
int[] playerStats = new int[4]; // 플레이어의 공격력, 방어력, 체력, 스피드를 저장할 배열

Random rand = new Random(); // 능력치를 랜덤으로 생성하여 배열에 저장
for (int i = 0; i < playerStats.Length; i++)
{
    playerStats[i] = rand.Next(1, 11);
}

Console.WriteLine("플레이어의 공격력: " + playerStats[0]);
Console.WriteLine("플레이어의 방어력: " + playerStats[1]);
Console.WriteLine("플레이어의 체력: " + playerStats[2]);
Console.WriteLine("플레이어의 스피드: " + playerStats[3]);
// 학생들의 성적 평균 구하기
int[] scores = new int[5];  // 5명의 학생 성적을 저장할 배열

for (int i = 0; i < scores.Length; i++) // 성적 입력 받기
{
    Console.Write("학생 " + (i + 1) + "의 성적을 입력하세요: ");
    scores[i] = int.Parse(Console.ReadLine());
}

int sum = 0; // 성적 총합 계산
for (int i = 0; i < scores.Length; i++)
{
    sum += scores[i];
}

double average = (double)sum / scores.Length;
Console.WriteLine("성적 평균은 " + average + "입니다."); // 성적 평균 출력
// 배열을 활용한 숫자 맞추기 게임
Random random = new Random();  // 랜덤 객체 생성
int[] numbers = new int[3];  // 3개의 숫자를 저장할 배열

for (int i = 0; i < numbers.Length; i++) // 3개의 랜덤 숫자 생성하여 배열에 저장
{
    numbers[i] = random.Next(1, 10);
}

int attempt = 0;  // 시도 횟수 초기화
while (true)
{
    Console.Write("3개의 숫자를 입력하세요 (1~9): ");
    int[] guesses = new int[3];  // 사용자가 입력한 숫자를 저장할 배열

    for (int i = 0;i < guesses.Length; i++)
    {
        guesses[i] = int.Parse(Console.ReadLine());
    }

    int correct = 0; // 맞춘 숫자의 개수 초기화

    for (int i = 0; i < numbers.Length; i++) // 숫자 비교 및 맞춘 개수 계산

    {
        for (int j = 0; j < guesses.Length; j++)
        {
            if (numbers[i] == guesses[j])
            {
                correct++;
                break;
            }
        }
    }

    attempt++;  // 시도 횟수 증가
    Console.WriteLine("시도 #" + attempt + ": " + correct + "개의 숫자를 맞추셨습니다.");

    // 모든 숫자를 맞춘 경우 게임 종료
    if (correct == 3)
    {
        Console.WriteLine("축하합니다! 모든 숫자를 맞추셨습니다.");
        break;
    }
}

 

다차원 배열

  • 여러 개의 배열을 하나로 묶어 놓은 배열
  • 행과 열로 이루어진 표 형태와 같은 구조
  • 2차원, 3차원 등의 형태의 배열을 의미
  • C#에서는 다차원 배열을 선언할 때 각 차원의 크기를 지정하여 생성한다.
// 2차원 배열의 선언과 초기화
int[,] array3 = new int[2, 3];  // 2행 3열의 int형 2차원 배열 선언

// 다차원 배열 초기화
array3[0, 0] = 1;
array3[0, 1] = 2;
array3[0, 2] = 3;
array3[1, 0] = 4;
array3[1, 1] = 5;
array3[1, 2] = 6;

// 선언과 함께 초기화
int[,] array2D = new int[3, 4] { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } };

 

3차원 이상은 잘 사용하지 않는다.

// 3차원 배열의 선언과 초기화
int[,,] array3D = new int[2, 3, 4] 
{
    { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } },
    { { 13, 14, 15, 16 }, { 17, 18, 19, 20 }, { 21, 22, 23, 24 } }
};

 

다차원 배열 예제

int[,] map = new int[5, 5];
for (int i = 0; i < 5; i++)
{
    for (int j = 0; j < 5; j++)
    {
        map[i, j] = i + j;
    }
}

for (int i = 0; i < 5; i++)
{
    for (int j = 0; j < 5; j++)
    {
        Console.Write(map[i, j] + " ");
    }
    Console.WriteLine();
}
  • 다차원 배열을 활용하면 복잡한 데이터 구조를 효율적으로 관리할 수 있다.
  • 2차원 배열은 행과 열로 이루어진 데이터 구조를 다루기에 적합하다.
  • 3차원 배열은 면, 행, 열로 이루어진 데이터 구조를 다루기에 적합하다.
// 게임 맵 구현
int[,] map = new int[5, 5] 
{ 
    { 1, 1, 1, 1, 1 }, 
    { 1, 0, 0, 0, 1 }, 
    { 1, 0, 1, 0, 1 }, 
    { 1, 0, 0, 0, 1 }, 
    { 1, 1, 1, 1, 1 } 
};

for (int i = 0; i < 5; i++)
{
    for (int j = 0; j < 5; j++)
    {
        if (map[i, j] == 1)
        {
            Console.Write("■ ");
        }
        else
        {
            Console.Write("□ ");
        }
    }
    Console.WriteLine();
}

 

 

컬렉션

자료를 모아놓은 데이터 구조

  • 컬렉션은 배열과 비슷한 자료 구조
  • 배열과는 다르게 크기가 가변적
  • C#에서는 다양한 종류의 컬렉션을 제공
  • 사용하기 위해서는 System.Collections.Generic 네임스페이스를 추가

 

List(리스트)

동적 배열. List를 생성할 때 담을 자료형을 지정해야한다.

List<int> numbers = new List<int>(); // 빈 리스트 생성
numbers.Add(1); // 리스트에 데이터 추가
numbers.Add(2);
numbers.Add(3);
numbers.Remove(2); // 리스트에서 데이터 삭제

for (int i = 0; i < numbers.Count; i++) // 리스트 데이터 출력 - for문
{
    Console.WriteLine(numbers[i]);
}

foreach (int number in numbers) // 리스트 데이터 출력 - foreach문
{
    Console.WriteLine(number);
}

 

Dictionary(딕셔너리)

키와 값으로 구성된 데이터 저장. 중복된 키를 가질 수 없고, 키와 값의 쌍을 이룬다.

Dictionary<string, int> scores = new Dictionary<string, int>(); // 빈 딕셔너리 생성
scores.Add("Alice", 100); // 딕셔너리에 데이터 추가
scores.Add("Bob", 80);
scores.Add("Charlie", 90);
scores.Remove("Bob"); // 딕셔너리에서 데이터 삭제

foreach(KeyValuePair<string, int> pair in scores) // 딕셔너리 데이터 출력
{
    Console.WriteLine(pair.Key + ": " + pair.Value);
}

 

Stack

후입선출(LIFO) 구조를 가진 자료 구조

Stack<int> stack1 = new Stack<int>();  // int형 Stack 선언

stack1.Push(1); // Stack에 요소 추가
stack1.Push(2);
stack1.Push(3);

int value = stack1.Pop(); // Stack에서 요소 가져오기

 

Queue

선입선출(FIFO) 구조를 가진 자료 구조

Queue<int> queue1 = new Queue<int>(); // int형 Queue 선언

queue1.Enqueue(1); // Queue에 요소 추가
queue1.Enqueue(2);
queue1.Enqueue(3);

int value = queue1.Dequeue(); // Queue에서 요소 가져오기

 

HashSet

중복되지 않은 요소들로 이루어진 집합

HashSet<int> set1 = new HashSet<int>();  // int형 HashSet 선언

set1.Add(1); // HashSet에 요소 추가
set1.Add(2);
set1.Add(3);

foreach (int element in set1) // HashSet에서 요소 가져오기
{
    Console.WriteLine(element);
}

 

 

 

조건문

코드의 참과 거짓을 판단하여 실행한다.

 

조건문 기초

// if문 기초
int playerScore = 80;

if (playerScore >= 70)
{
    Console.WriteLine("플레이어의 점수는 70점 이상입니다. 합격입니다!");
}
Console.WriteLine("프로그램이 종료됩니다.");

// else문 기초
if (itemCount > 0)
{
    Console.WriteLine($"보유한 {itemName}의 수량: {itemCount}");
}
else
{
    Console.WriteLine($"보유한 {itemName}이 없습니다.");
}

if문과 else문은 하나의 쌍이며 else문은 생략 가능하다.

 

// else if문 실습
int score = 100;
string playerRank = "";

if (score >= 90)
{
    playerRank = "Diamond";
}
else if (score >= 80)
{
    playerRank = "Platinum";
}
else if (score >= 70)
{
    playerRank = "Gold";
}
else if (score >= 60)
{
    playerRank = "Silver";
}
else
{
    playerRank = "Bronze";
}

Console.WriteLine("플레이어 등급은 {0} 입니다.", playerRank);

 

// switch문
Console.WriteLine("게임을 시작합니다.");
Console.WriteLine("1: 전사 / 2: 마법사 / 3: 궁수");
Console.Write("직업을 선택하세요: ");
string job = Console.ReadLine();

switch (job)
{
    case "1":
        Console.WriteLine("전사를 선택하셨습니다.");
        break;
    case "2":
        Console.WriteLine("마법사를 선택하셨습니다.");
        break;
    case "3":
        Console.WriteLine("궁수를 선택하셨습니다.");
        break;
    default:
        Console.WriteLine("올바른 값을 입력해주세요.");
        break;
}

Console.WriteLine("게임을 종료합니다.");

 

 

// 중첩 조건문
int itemLevel = 3; // 아이템 레벨
string itemType = "Weapon"; // 아이템 종류

if (itemType == "Weapon")
{
    if (itemLevel == 1)
    {
        // 레벨 1 무기 효과
        Console.WriteLine("공격력이 10 증가했습니다.");
    }
    else if (itemLevel == 2)
    {
        // 레벨 2 무기 효과
        Console.WriteLine("공격력이 20 증가했습니다.");
    }
    else
    {
        // 그 외 무기 레벨
        Console.WriteLine("잘못된 아이템 레벨입니다.");
    }
}
else if (itemType == "Armor")
{
    if (itemLevel == 1)
    {
        // 레벨 1 방어구 효과
        Console.WriteLine("방어력이 10 증가했습니다.");
    }
    else if (itemLevel == 2)
    {
        // 레벨 2 방어구 효과
        Console.WriteLine("방어력이 20 증가했습니다.");
    }
    else
    {
        // 그 외 방어구 레벨
        Console.WriteLine("잘못된 아이템 레벨입니다.");
    }
}
else
{
    // 그 외 아이템 종류
    Console.WriteLine("잘못된 아이템 종류입니다.");
}

 

삼항 연산자

(조건식) ? 참일 경우 값 : 거짓일 경우 값;
int currentExp = 1200;
int requiredExp = 2000;

// 삼항 연산자
string result = (currentExp >= requiredExp) ? "레벨업 가능" : "레벨업 불가능";
Console.WriteLine(result);


// if else문
if (currentExp >= requiredExp)
{
    Console.WriteLine("레벨업 가능");
}
else
{
    Console.WriteLine("레벨업 불가능");
}

 

조건문 심화

// 홀수 / 짝수 구분하기 - if문
Console.Write("번호를 입력하세요: ");
int number = int.Parse(Console.ReadLine());

if (number % 2 == 0)
{
    Console.WriteLine("짝수입니다.");
}
else
{
    Console.WriteLine("홀수입니다.");
}


// 홀수 / 짝수 구분하기 - 삼항 연산자
Console.Write("번호를 입력하세요: ");
string result = (int.Parse(Console.ReadLine()) % 2 == 0) ? "짝수입니다." : "홀수입니다.";
Console.Write(result);
// 등급 출력 - switch문
int playerScore = 100;
string playerRank = "";

switch (playerScore / 10)
{
    case 10:
    case 9:
        playerRank = "Diamond";
        break;
    case 8:
        playerRank = "Platinum";
        break;
    case 7:
        playerRank = "Gold";
        break;
    case 6:
        playerRank = "Silver";
        break;
    default:
        playerRank = "Bronze";
        break;
}

Console.WriteLine("플레이어의 등급은 " + playerRank + "입니다.");
// 로그인 프로그램
string id = "myid";
string password = "mypassword";

Console.Write("아이디를 입력하세요: ");
string inputId = Console.ReadLine();
Console.Write("비밀번호를 입력하세요: ");
string inputPassword = Console.ReadLine();

if (inputId == id && inputPassword == password)
{
    Console.WriteLine("로그인 성공!");
}
else
{
    Console.WriteLine("로그인 실패...");
}
// 알파벳 판별 프로그램
Console.Write("문자를 입력하세요: ");
char input = Console.ReadLine()[0];

if (input >= 'a' && input <= 'z' || input >= 'A' && input <= 'Z')
{
    Console.WriteLine("알파벳입니다.");
}
else
{
    Console.WriteLine("알파벳이 아닙니다.");
}

// 알파벳 판별 프로그램 - 삼항 연산자
Console.Write("문자를 입력하세요: ");
char c = Console.ReadLine()[0];
string alp = (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z') ? "알파벳입니다." : "알파벳이 아닙니다.";
Console.WriteLine(alp);

 

 

반복문

일련의 코드를 몇 번 반복하거나 조건에 해당할 때까지 반복을 도는 과정

 

반복문 기초

// for 문 기초
for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
}

int j = 0;
for (j = 0; j < 10; j++)
{
    Console.WriteLine(j);
}

 

// while문 기초
int k = 0;
while (k < 10)
{
    Console.WriteLine(k);
    k++;
}

int count = 0;
while (count < 10)
{
    Console.WriteLine("적을 처치했습니다! 남은 적 수: " + (10 - count - 1));
    count++;
}

Console.WriteLine("축하합니다! 게임에서 승리하셨습니다!");

for문은 명확한 회차나 데이터가 있을 때 사용하기 좋고 while문은 조건에 부합하는 반복을 돌릴 때 사용하기 좋다.

 

// for 문 vs while 문
int sum1 = 0;

for (int i = 1; i <= 5; i++)
{
    sum1 += i;
}

Console.WriteLine("1부터 5까지의 합은 " + sum1 + "입니다.");

int sum2 = 0;
int k = 1;

while (k <= 5)
{
    sum2 += k;
    k++;
}

Console.WriteLine("1부터 5까지의 합은 " + sum2 + "입니다.");
  • for 문은 반복 횟수를 직관적으로 알 수 있고, 반복 조건을 한 눈에 확인할 수 있어 가독성이 좋다.
  • while 문은 반복 조건에 따라 조건문의 실행 횟수가 유동적이며, 이에 따라 코드가 더 간결할 수 있다.
// do while문
int sum = 0;
int num;

do
{
    Console.Write("숫자를 입력하세요 (0 입력 시 종료): ");
    num = int.Parse(Console.ReadLine());
    sum += num;
} while (num != 0);

Console.WriteLine("합계: " + sum);

// for each문
string[] inventory = { "검", "방패", "활", "화살", "물약" };

foreach (string item in inventory)
{
    Console.WriteLine(item);
}

 

// 중첩 반복문 - 이차원 반복문
// 구구단 출력
for (int i = 2; i <= 9; i++)
{
    for (int j = 1; j <= 9; j++)
    {
        Console.WriteLine(i + " x " + j + " = " + (i * j));
    }
}

// 구구단 가로
for (int i = 2; i <= 9; i++)
{
    for (int j = 1; j <= 9; j++)
    {
        Console.Write(i + " x " + j + " = " + (i * j) + "\t");
    }
    Console.WriteLine();
}

// 구구단 세로
for (int i = 1; i <= 9; i++)
{
    for (int j = 2; j <= 9; j++)
    {
        Console.Write(j + " x " + i + " = " + (i * j) + "\t");
    }
    Console.WriteLine();
}

 

Break & Continue

// Break & Continue
for (int i = 1; i <= 10; i++)
{
    if (i % 3 == 0)
    {
        continue; // 3의 배수인 경우 다음 숫자로 넘어감
    }

    Console.WriteLine(i);
    if (i == 7)
    {
        break; // 7이 출력된 이후에는 반복문을 빠져나감
    }
}

// Break & Continue 예제
int sum = 0;

while (true)
{
    Console.Write("숫자를 입력하세요: ");
    int input = int.Parse(Console.ReadLine());

    if (input == 0)
    {
        Console.WriteLine("프로그램을 종료합니다.");
        break;
    }

    if (input < 0)
    {
        Console.WriteLine("음수는 무시합니다.");
        continue;
    }

    sum += input;
    Console.WriteLine("현재까지의 합: " + sum);
}

Console.WriteLine("합계: " + sum);

 

반복문 심화

// 가위바위보
string[] choices = { "가위", "바위", "보" };
string playerChoice = "";
string computerChoice = "";

while (true)
{
    computerChoice = choices[new Random().Next(0, 3)];
    Console.Write("가위, 바위, 보 중 하나를 선택하세요: ");
    playerChoice = Console.ReadLine();

    Console.WriteLine("컴퓨터: " + computerChoice);

    if (playerChoice == computerChoice)
    {
        Console.WriteLine("비겼습니다!");
    }
    else if ((playerChoice == "가위" && computerChoice == "보") ||
             (playerChoice == "바위" && computerChoice == "가위") ||
             (playerChoice == "보" && computerChoice == "바위"))
    {
        Console.WriteLine("플레이어 승리!");
    }
    else if ((playerChoice == "가위" && computerChoice == "바위") ||
             (playerChoice == "바위" && computerChoice == "보") ||
             (playerChoice == "보" && computerChoice == "가위"))
    {
        Console.WriteLine("컴퓨터 승리!");
    }
    else
    {
        Console.WriteLine("가위, 바위, 보 중 하나를 선택하세요! ");
    }
}

// 숫자 맞추기
int targetNumber = new Random().Next(1, 101); ;
int guess = 0;
int count = 0;

Console.WriteLine("1부터 100 사이의 숫자를 맞춰보세요.");

while (guess != targetNumber)
{
    Console.Write("추측한 숫자를 입력하세요: ");
    guess = int.Parse(Console.ReadLine());
    count++;

    if (guess < targetNumber)
    {
        Console.WriteLine("좀 더 큰 숫자를 입력하세요.");
    }
    else if (guess > targetNumber)
    {
        Console.WriteLine("좀 더 작은 숫자를 입력하세요.");
    }
    else
    {
        Console.WriteLine("축하합니다! 숫자를 맞추셨습니다.");
        Console.WriteLine("시도한 횟수: " + count);
    }
}

+ Recent posts