[어서와 Java는 처음이지!_2019 Ver] 4장 Lab 도전문제 풀이

# 4장 Lab 도전문제 풀이

 

155p_Lab 도전문제)

package chap04;

import java.util.*;

public class Lab_Advanced_155p {

	public static void main(String[] args) {
		int STUDENTS = 1;
		int total = 0;
		
		Scanner scan = new Scanner(System.in);
		
		System.out.println("학생 수: ");
		STUDENTS = scan.nextInt();
		
		int[] scores = new int[STUDENTS];

		for (int i = 0; i < scores.length; i++)
		{
			System.out.print("성적을 입력하시오: ");
			scores[i] = scan.nextInt();
		}
		
		for (int i = 0; i < scores.length; i++)
		{
			total = total + scores[i];
		}
		
		System.out.println("평균: " + (total/STUDENTS));
	}
}

 

 

---

 

158p_Lab 도전문제)

package chap04;

public class Lab_Advanced_158p {

	public static void main(String[] args) {
		double[] numbers = { 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9 };
		
		for ( int i = 0; i < numbers.length; i++)
		{
			if (numbers[i] == 0.9)
			{
				System.out.print(numbers[i]);
			}
			else
			{
				System.out.print(numbers[i] + ", ");
			}
		}
	}
}

 

 

---

 

160p_Lab 도전문제)

package chap04;

public class Lab_Advanced_160p {

	public static void main(String[] args) {
		int s[] = { 12, 3, 14, 2, 11 };
		int max_num;
		
		max_num = s[0];
		
		for(int i = 1; i < s.length; i++)
		{
			if(s[i] > max_num)
			{
				max_num = s[i];
			}
		}
		
		System.out.print("최댓값: " + max_num);
	}
}

 

 

---

 

162p_Lab 도전문제)

package chap04;

import java.util.*;

public class Lab_Advanced_162p {

	public static void main(String[] args) {
		int s[] = { 1, 2, 3, 4, 5 };
		int value, index = -1;

		Scanner scan = new Scanner(System.in);
		System.out.print("탐색할 값을 입력하시오: ");
		value = scan.nextInt();

		// 이진 탐색을 위한 탐색 범위 초기화
		int low = 0; // 탐색 범위의 가장 왼쪽 인덱스
		int high = s.length - 1; // 탐색 범위의 가장 오른쪽 인덱스

		while (low <= high) 
		{
			int mid = (low + high) / 2; // 탐색 범위의 중간 인덱스 계산

			if (s[mid] == value) 
			{ // 찾고자 하는 값과 일치하는 경우
				index = mid; // 인덱스 저장
				break; // 탐색 종료
			} 
			else if (s[mid] < value) 
			{ // 중간 값이 찾고자 하는 값보다 작은 경우
				low = mid + 1; // 탐색 범위를 오른쪽 반쪽으로 좁힘
			} 
			else 
			{ // 중간 값이 찾고자 하는 값보다 큰 경우
				high = mid - 1; // 탐색 범위를 왼쪽 반쪽으로 좁힘
			}
		}

		if (index >= 0) { // 찾은 값이 있는 경우
			System.out.println(value + "값은 " + index + "위치에 있다.");
		}
	}
}

 

더 빠른 탐색을 위해 이진 탐색(Binary Search) 기법 사용

 

---

 

※ 이진 탐색(Binary Search) ※

탐색 범위를 반으로 나누어 찾고자 하는 값과 비교하면서 탐색 범위를 좁혀나가는 방법으로,
주로 배열이 정렬된 상태에서 사용된다.

 

+ 이미지 출처

https://ko.wikipedia.org/wiki/%EC%9D%B4%EC%A7%84_%EA%B2%80%EC%83%89_%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98

이진 검색 알고리즘 - 위키백과, 우리 모두의 백과사전

 

---

 

177p_Lab 도전문제)

package chap04;
import java.util.Scanner;
import java.util.Random;

public class Lab_Advanced_177p {

	public static void main(String[] args) {
		char[][] board = new char[3][3];
        int x;
        int y;

        Scanner scan = new Scanner(System.in);

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                board[i][j] = ' ';
            }
        }

        do {
            for (int i = 0; i < 3; i++) {
                System.out.println("  " + board[i][0] + "|  " + board[i][1] + "|  " + board[i][2]);

                if (i != 2) {
                    System.out.println("---|---|---");
                }
            }

            System.out.println("다음 수의 좌표: ");
            x = scan.nextInt();
            y = scan.nextInt();

            if (x < 0 || x > 2 || y < 0 || y > 2) {
                System.out.println("잘못된 위치를 선택하셨습니다.");
                continue;
            }

            if (board[x][y] != ' ') {
                System.out.println("이미 놓여진 자리입니다. 다른 자리를 선택하세요.");
                continue;
            } else {
                board[x][y] = 'X';
            }

            // 게임판이 가득 찼는지 확인
            boolean isBoardFull = true;
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 3; j++) {
                    if (board[i][j] == ' ') {
                        isBoardFull = false;
                        break;
                    }
                }
            }

            // 게임판이 가득 찼으면 게임 종료
            if (isBoardFull) {
                System.out.println("게임 종료: 더 이상 놓을 공간이 없습니다.");
                break;
            }

            // 플레이어(X)가 승리했는지 확인
            if (checkWin(board, 'X')) {
                System.out.println("게임 종료: 플레이어 (X) 승리!");
                break;
            }

            // 컴퓨터의 차례 (O)
            Random random = new Random();
            int compX, compY;

            // 컴퓨터가 다음 수로 승리할 수 있는지 확인
            boolean isComputerWin = false;
            for (compX = 0; compX < 3; compX++) {
                for (compY = 0; compY < 3; compY++) {
                    if (board[compX][compY] == ' ') {
                        board[compX][compY] = 'O';
                        if (checkWin(board, 'O')) {
                            System.out.println("컴퓨터 (O)가 이겼습니다!");
                            isComputerWin = true;
                            break;
                        }
                        board[compX][compY] = ' '; // 수를 놓고 다시 되돌림
                    }
                }
                if (isComputerWin) {
                    break;
                }
            }

            if (isComputerWin) {
                scan.close();
                return;
            }

            // 플레이어가 다음 수로 승리할 수 있는지 확인하고 막기
            boolean isPlayerWinBlocked = false;
            for (compX = 0; compX < 3; compX++) {
                for (compY = 0; compY < 3; compY++) {
                    if (board[compX][compY] == ' ') {
                        board[compX][compY] = 'X';
                        if (checkWin(board, 'X')) {
                            board[compX][compY] = 'O'; // 승리하는 수를 막음
                            isPlayerWinBlocked = true;
                            break;
                        } else {
                            board[compX][compY] = ' '; // 수를 놓고 다시 되돌림
                        }
                    }
                }
                if (isPlayerWinBlocked) {
                    break;
                }
            }

            // 승리할 수 있는 수가 없거나 막을 수 없으면 무작위로 수를 놓음
            if (!isComputerWin && !isPlayerWinBlocked) {
                while (true) {
                    compX = random.nextInt(3);
                    compY = random.nextInt(3);

                    if (board[compX][compY] == ' ') {
                        board[compX][compY] = 'O';
                        break;
                    }
                }
            }

            // 컴퓨터 (O)가 승리했는지 확인
            if (checkWin(board, 'O')) {
                System.out.println("게임 종료: 컴퓨터 (O) 승리!");
                break;
            }
        } while (true);

        scan.close();
    }

    // 플레이어 (X 또는 O)가 승리했는지 확인하는 함수
    public static boolean checkWin(char[][] board, char player) {
        for (int i = 0; i < 3; i++) {
            // 행 확인
            if (board[i][0] == player && board[i][1] == player && board[i][2] == player) {
                return true;
            }

            // 열 확인
            if (board[0][i] == player && board[1][i] == player && board[2][i] == player) {
                return true;
            }
        }

        // 대각선 확인
        if (board[0][0] == player && board[1][1] == player && board[2][2] == player) {
            return true;
        }
        if (board[0][2] == player && board[1][1] == player && board[2][0] == player) {
            return true;
        }

        return false;
    }
}

 

 

 

---

 

++ 컴퓨터의 수 선택에 사용한 알고리즘

 

A) 컴퓨터가 다음 수로 승리할 수 있는지 확인하는 알고리즘

1️⃣ isComputerWin 변수를 사용하여 컴퓨터의 승리 여부 확인
2️⃣ 이중 반복문을 통해 board 배열의 빈 공간 탐색
3️⃣ 빈 공간에 컴퓨터('O')를 놓은 후 checkWin 메서드를 호출하여 컴퓨터의 승리 여부 확인
4️⃣ 컴퓨터가 승리하면 isComputerWin을 true로 설정하고 루프 탈출

 

B) 컴퓨터가 플레이어의 승리를 막기 위한 알고리즘

1️⃣ isPlayerWinBlocked 불리언 변수를 사용하여 플레이어의 승리를 막을 수 있는지 확인
2️⃣ 다시 이중 반복문을 통해 board 배열의 빈 공간 탐색
3️⃣ 빈 공간에 플레이어('X')를 놓은 후 checkWin 메서드를 호출하여 플레이어가 승리하는 경우 확인
4️⃣ 승리 가능한 경우가 있다면, 해당 위치에 컴퓨터('O')를 놓아 플레이어의 승리 방해

 

C) 승리 가능한 수가 없거나 플레이어의 승리를 막을 수 없는 경우의 수 선택 알고리즘

1️⃣ 컴퓨터는 남은 빈 공간 중 무작위로 하나를 선택

 

---

179p_Lab 도전문제)

package chap04;
import java.util.Scanner;

public class Lab_Advanced_179p {

    public static void main(String[] args) {
        boolean[][] board = new boolean[10][10];
        int[][] mineCounts = new int[10][10];
        char[][] userView = new char[10][10];

        // Initialize the board with mines (true values)
        // For this example, let's say we have mines at positions (2, 2), (4, 5), and (8, 9)
        board[2][2] = true;
        board[4][5] = true;
        board[8][9] = true;

        // Initialize the user view with hidden cells
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                userView[i][j] = '*';
            }
        }

        Scanner scanner = new Scanner(System.in);

        while (true) {
            // Print the user view of the board
            printBoard(userView);

            // Ask the user to enter the cell coordinates to reveal
            System.out.print("Enter row and column (e.g., 2 3) or 'q' to quit: ");
            String input = scanner.nextLine().trim().toLowerCase();

            if (input.equals("q")) {
                System.out.println("Thanks for playing. Goodbye!");
                break;
            }

            try {
                String[] parts = input.split(" ");
                int row = Integer.parseInt(parts[0]);
                int col = Integer.parseInt(parts[1]);

                // Check if the entered coordinates are valid
                if (row < 0 || row >= 10 || col < 0 || col >= 10) {
                    System.out.println("Invalid coordinates. Please try again.");
                    continue;
                }

                // Check if the cell is already revealed
                if (userView[row][col] != '*') {
                    System.out.println("Cell already revealed. Please try again.");
                    continue;
                }

                // Reveal the cell based on the board's content
                if (board[row][col]) {
                    // The cell contains a mine
                    System.out.println("Oops! You hit a mine. Game Over!");
                    printBoard(board); // Print the board with mine positions
                    break;
                } else {
                    // The cell does not contain a mine, reveal the count of neighboring mines
                    userView[row][col] = (char) (countNeighboringMines(board, row, col) + '0');
                }
            } catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
                System.out.println("Invalid input format. Please enter row and column numbers separated by space.");
            }
        }
    }

    // Helper method to print the user view of the board
    private static void printBoard(char[][] board) {
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.print(board[i][j] + " ");
            }
            System.out.println();
        }
    }

    // Helper method to print the board with mine positions
    private static void printBoard(boolean[][] board) {
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.print(board[i][j] ? "M " : ". "); // "M" for mine, "." for empty cell
            }
            System.out.println();
        }
    }

    // Helper method to count neighboring mines for a cell
    private static int countNeighboringMines(boolean[][] board, int x, int y) {
        int count = 0;
        for (int i = Math.max(0, x - 1); i <= Math.min(x + 1, 9); i++) {
            for (int j = Math.max(0, y - 1); j <= Math.min(y + 1, 9); j++) {
                if (board[i][j]) {
                    count++;
                }
            }
        }
        return count;
    }
}