🚗 자동차 경주 게임 #2022.02.08~2022.02.18

2022 / 02.08~02.18

미션 - 자동차 경주 게임

🚀 기능 요구사항

• 주어진 횟수 동안 n대의 자동차는 전진 또는 멈출 수 있다.
• 각 자동차에 이름을 부여할 수 있다. 전진하는 자동차를 출력할 때 자동차 이름을 같이 출력한다.
• 자동차 이름은 쉼표(,)를 기준으로 구분하며 이름은 5자 이하만 가능하다.
• 사용자는 몇 번의 이동을 할 것인지를 입력할 수 있어야 한다.
• 전진하는 조건은 0에서 9 사이에서 random 값을 구한 후 random 값이 4 이상일 경우 전진하고, 3 이하의 값이면 멈춘다.
• 자동차 경주 게임을 완료한 후 누가 우승했는지를 알려준다. 우승자는 한 명 이상일 수 있다.

✍🏻 입출력 요구사항

⌨️ 입력

• 경주 할 자동차 이름(이름은 쉼표(,) 기준으로 구분)

pobi,woni,jun

• 시도할 회수

5

🖥 출력

• 각 차수별 실행 결과

pobi : --
woni : ----
jun : ---

• 단독 우승자 안내 문구

최종 우승자: pobi

• 공동 우승자 안내 문구

최종 우승자: pobi, jun

• 예외 상황 시 에러 문구를 출력해야 한다. 단, 에러 문구는 [ERROR] 로 시작해야 한다.

[ERROR] 시도 횟수는 숫자여야 한다.

---

 

 

### 

- static 변수는 non-static 변수보다 위에 선언

- 메서드명은 동사 or 동사+명사

- 메서드명 or return 타입 주의

메서드명이 get~ 이라면 return 타입 존재해야함

(+ 메서드명이 is~ 라면 return 타입은 boolean)

ex

- index가 필요하지 않은 경우 향상된 for문 사용

 

### code ### 

package racingCar;

public class Application {
    public static void main(String[] args) {
        RacingCarGame racingCarGame = new RacingCarGame();
        racingCarGame.play();
    }
}

 

package racingCar;

import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Scanner;

class RacingCarGame {
    private static final int NAME_LENGTH_STANDARD = 5;
    private static final int NOT_A_NUMBER = -1;
    final Scanner scanner = new Scanner(System.in);

    public void play() {
        String[] names = inputNames();
        int tryNumber = inputTryNumber();
        List<Car> cars = createCars(names);

        System.out.println("실행 결과");
        for (int i = 0; i < tryNumber; i++)
            printRaceResult(cars);

        System.out.print("최종 우승자: ");
        List<String> winners = findWinner(cars);
        printWinner(winners);
    }

    public int inputTryNumber() {
        int tryNumber = NOT_A_NUMBER;

        while (!isNumber(tryNumber)) {
            try {
                System.out.println("시도할 횟수는 몇회인가요?");
                tryNumber = scanner.nextInt();
            } catch (InputMismatchException ime) {
                System.out.println("[ERROR] 시도 횟수는 숫자여야 한다.");
                tryNumber = NOT_A_NUMBER;
                scanner.next();
            }
        }
        return tryNumber;
    }

    public boolean isNumber(int tryNumber) {
        return tryNumber != NOT_A_NUMBER;
    }

    public String[] splitNames(String name) {
        return name.split(",");
    }

    public boolean checkNameLength(String[] names) {
        for (String name : names) {
            if (name.length() > NAME_LENGTH_STANDARD) {
                System.out.println("[ERROR] 5자 이하의 이름으로 입력하세요.");
                return false;
            }
        }
        return true;
    }

    private String[] inputNames() {
        boolean check;
        String[] names;

        System.out.println("경주할 자동차 이름을 입력하세요. (이름은 쉼표(,) 기준으로 구분)");
        do {
            String name = scanner.next();
            names = splitNames(name);
            check = checkNameLength(names);
        } while (!check);

        return names;
    }

    public List<Car> createCars(String[] names) {
        List<Car> cars = new ArrayList<>();

        for (String name : names) {
            Car car = new Car(name);
            cars.add(car);
        }
        return cars;
    }

    private void printRaceResult(List<Car> cars) {
        for (int i = 0; i < cars.size(); i++) {
            Car car = cars.get(i);
            int count = car.getMoveCount();
            car.printMove(count);
            System.out.println("");
        }
        System.out.println("");
    }

    public int getMaxPositionIdx(List<Car> cars, Car car, int maxPosition) {
        int maxPositionIdx = 0;

        for (int i = 0; i < cars.size(); i++) {
            car = cars.get(i);
            int position = car.getPosition();

            if (maxPosition < position) {
                maxPosition = position;
                maxPositionIdx = i;
            }
        }

        return maxPositionIdx;
    }

    public List<Integer> getCoWinnerIdx(List<Car> cars, int maxPositionIdx) {
        List<Integer> coWinnerIdx = new ArrayList<Integer>();
        Car car = cars.get(maxPositionIdx);
        int maxPosition = car.getPosition();

        for (int i = maxPositionIdx + 1; i < cars.size(); i++) {
            car = cars.get(i);
            if (maxPosition == car.getPosition()) {
                coWinnerIdx.add(i);
            }
        }

        return coWinnerIdx;
    }

    private void addWinner(List<Car> cars, List<String> winners, int maxPositionIdx) {
        Car car = cars.get(maxPositionIdx);
        String winnerName = car.getName();
        winners.add(winnerName);
    }

    private List<String> findWinner(List<Car> cars) {
        List<String> winners = new ArrayList<>();
        Car initialCar = cars.get(0);
        int initialPosition = initialCar.getPosition();
        int maxPositionIdx = getMaxPositionIdx(cars, initialCar, initialPosition);
        addWinner(cars, winners, maxPositionIdx);

        List<Integer> coWinnerIndex = getCoWinnerIdx(cars, maxPositionIdx);
        for (int coWinnerIdx : coWinnerIndex)
            addWinner(cars, winners, coWinnerIdx);

        return winners;
    }

    public String printWinner(List<String> winners) {
        String winner = String.join(", ", winners);
        System.out.println(winner);
        return winner;
    }
}

package racingCar;

import utils.RandomUtils;

public class Car {
    private static final int START_INCLUSIVE = 0;
    private static final int END_INCLUSIVE = 9;
    private static final int MOVING_STANDARD = 4;
    private final String name;
    private int position = 0;

    public Car(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    private int getNumber() {
        return RandomUtils.nextInt(START_INCLUSIVE, END_INCLUSIVE);
    }

    public int getPosition() {
        return this.position;
    }

    public void moveOrStop(int number) {
        if (number >= MOVING_STANDARD)
            this.position++;
    }

    public int getMoveCount(){
        int number = getNumber();
        moveOrStop(number);

        int moveCount = this.getPosition();

        return moveCount;
    }

    public String printMove(int count) {
        String move = "";
        char racePoint = '-';

        System.out.print(this.name + ":");
        for (int i = 0; i < count; i++) {
            move += racePoint;
            System.out.print("-");
        }
        return move;
    }
}​

package utils;

import java.util.Random;

public class RandomUtils {
    private static final Random RANDOM = new Random();

    private RandomUtils() {
    }

    public static int nextInt(final int startInclusive, final int endInclusive) {
        if (startInclusive > endInclusive) {
            throw new IllegalArgumentException();
        }

        if (startInclusive < 0) {
            throw new IllegalArgumentException();
        }

        if (startInclusive == endInclusive) {
            return startInclusive;
        }

        return startInclusive + RANDOM.nextInt(endInclusive - startInclusive + 1);
    }
}