๐งฉโ๏ธ๐ค๐ต๏ธโ๐ก๐ฏโโญ
PICTURE
= 7์๋ฆฌ โ _ _ _ _ _ _ _
A-Z
์ฌ์ด์ ์ํ๋ฒณ์ด ์๋๋ผ๋ฉด ๋ค์ ์
๋ ฅ์ ๋ฐ์ต๋๋ค.eyes
์ธ ๊ฒฝ์ฐ์ E
๋ฅผ ์
๋ ฅํ์ ๋ ____
โ E_E_
์ผ๋จ ํ์๋ ์ฒ์์ ๋จ์ด์ ๋ํ ํํธ๋ฅผ ์ฃผ๋ ๊ฒ์ ์๊ฐํ๋ ๋จธ๋ฆฌ๊ฐ ์ํ์๋ค.
๊ทธ๋์ ์ผ๋จ ํ๋งจ์ด๋ผ๋ ๊ฒ์๊ณผ ๋งค์ฐ ์ ์ฌํ๋ค๊ณ ์๊ฐํ๊ณ ์ฝ๋๋ฅผ ์์ฑํ๋ค.
ํํธ๋ฅผ ์ฃผ์ง ์์๋ ๊ธฐํ๊ฐ 9๋ฒ์ด๋ฉด ๋๋ฆ ํด๋ณผ๋ง ํ ๊ฒ ๊ฐ๋ค๊ณ ์๊ฐํ๋ค.
๋ชจ์๋ง ๋ฃ์ด๋ ๊ฝค ์ ํ ์ ์์ง ์์๊น(?)
๋ฌธ์ ์ ์ ๋ต์ผ๋ก ์ฃผ์ด์ง ๋จ์ด๋ค์ ์ด๋ป๊ฒ ํ ๊น ์๊ฐํ๋ค.
๋จ์ด๋ค์ ์๊ฐ ๋ง์ํ
๋ ๋จ์ด๋ค์ ๋ชจ์๋๋ ํ์ผ์ ๋ฐ๋ก ์์ฑํ๊ธฐ๋ก ์๊ฐํ๋ค.
public class WordList {
public static final List<String> WORDS = Arrays.asList(
"apple", "banana", "cherry", ...);
}
๋จ์ด ๋ชฉ๋ก์ ๋ค๋ฅธ ๊ณณ์์ ์ฌ์ฉํ๊ณ ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ฑ์ ์๊ฐ(?)ํ์ฌ, List
๋ฅผ static
์ผ๋ก ์ ์ธํ์๋ค.
์ ๋ต์ผ๋ก ์ฌ์ฉ๋ ๋จ์ด ํ๋๋ฅผ ๊ฐ์ ธ์์ผ ํ๋๊น Random
ํด๋์ค๋ก ์ธ์คํด์ค๋ฅผ ์์ฑํ์ฌ ๋๋ค ๋ณ์๋ฅผ ํ๋ ์์ฑํ๊ณ , ๋จ์ด ๋ชจ์์ง์ผ๋ก ๋ง๋ค์ด ๋ WordList
ํ์ผ์ WORDS
๋ฅผ ๊ฐ์ ธ์์ List.get()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๋จ์ด ํ๋๋ฅผ ์ ์ฅํ๊ธฐ๋ก ํ๋ค.
Random random = new Random();
List<String> wordList = WordList.WORDS;
int index = random.nextInt(wordList.size()); // ๋จ์ด ๋ชฉ๋ก์ง์์ ๋๋ค์ผ๋ก ํ๋ ๊ณ ๋ฅด๊ธฐ ์ํ ๋๋ค ๋ฒํธ
String selectedWord = wordList.get(index).toUpperCase(); // ๊ณ ๋ฅธ ๋จ์ด๋ฅผ ๋๋ฌธ์ํ
char[] solutionWordArray = selectedWord.toCharArray();
๋ค์์๋ ๊ธฐ์ ํ๊ฒ ์ง๋ง solutionWordArray
๋ฅผ char[]
๋ก ์ ์ธํ ์ด์ ๋ String
ํํ๋ฅผ ____
์ด๋ฐ์์ผ๋ก ๋ฐ๊ฟ์ผํ๊ณ ํ๋ ์ด์ด๊ฐ ์
๋ ฅํด์ ๋ง์ถ ์ํ๋ฒณ์ด String
๋ฆฌํฐ๋ด ์์ ์์์ ๋น๊ต๋ฅผ ํ์ฌ ์ผ์นํ๋ ๋ถ๋ถ์ด ์์ผ๋ฉด ๋ชจ๋ ๋ฐ๊ฟ์ค์ผ ํ๋ค๊ณ ์๊ฐํ๊ธฐ ๋๋ฌธ์ด๋ค.
char[] currentGuessState = new char[solutionWordArray.length];
ํ๋ ์ด์ด๊ฐ ๋ง๋ ๋ต์ ์
๋ ฅํ์ ๋ ๋ง๋ค _
๋ฅผ ์ํ๋ฒณ์ผ๋ก ์นํํ๊ธฐ ์ํด์ _
๋ก๋ง ๊ตฌ์ฑ๋ ๋ฐฐ์ด๋ ํ๋ ์ ์ธํ์๋ค.
char[] currentGuessState = new char[solutionWordArray.length];
for (int i = 0; i < solutionWordArray.length; i++) {
currentGuessState[i] ='_';
}
๋จ์ ๊ธฐํ๋ฅผ ํ์ํ ๋ณ์, ํ๋ ์ด์ด์๊ฒ ์ํ๋ฒณ์ ์
๋ ฅ๋ฐ๊ธฐ ์ํ Scanner
ํด๋์ค,
ํ๋ ์ด์ด๊ฐ ์ด๋ฏธ ์
๋ ฅํ ์ํ๋ฒณ์ ์ถ์ ํ๊ธฐ ์ํด ์ค๋ณต์ ํ์ฉํ์ง ์๋set
์ ์ ์ธํ์๋ค.
int count = 9; // ๋จ์ ๊ธฐํ
Scanner sc = new Scanner(System.in); // ๋จ์ด ์
๋ ฅ๋ฐ๊ธฐ
Set<Character> usedLetters = new HashSet<>(); // ๊ณผ๊ฑฐ์ ์
๋ ฅ๋ ์ํ๋ฒณ ์ถ์
๊ฒ์์์ ์ค์ ๋ ๊ธฐํ์ธ count
๋ฅผ ๋ชจ๋ ์ฌ์ฉํ๋ฉด ๊ฒ์์ ์ข
๋ฃ์ํค๊ธฐ๋ก ์๊ฐํ๋ค.
๊ทธ๋์ while
๋ฌธ์ (count > 0)
์กฐ๊ฑด์ ๊ฑธ์๋ค.
์ด์ ๊ทธ ์์์ ์
๋ ฅ ๊ฐ ๊ฒ์ฆ ๋ฐ ์ถ์ , ๊ฒ์ ์นํจ ์ฌ๋ถ์ ๊ดํ ์ฝ๋๋ฅผ ์ง๊ธฐ์ํ ์๊ฐ์ ํด์ผํ๋ค.
while (count > 0){
// ๋ฌธ์ ์๋ด
// ํ๋ ์ด์ด ์
๋ ฅ
// ์
๋ ฅ ๊ฐ ๊ฒ์ฆ
// ๋ง์ถ ๋ต ์
๋ฐ์ดํธ
// ๊ฒ์ ์น๋ฆฌ ์๋ด
}
// ๊ฒ์ ํจ๋ฐฐ ์๋ด
์ด์ while
๋ฌธ ์์์ ํ๋ ์ด์ด์ ์
๋ ฅ ๊ฐ์ ๊ฒ์ฆ์ ํด์ผํ๋ค.
๋จผ์ ์
๋ ฅ ๊ฐ์ด ์ํ๋ฒณ์ด์ฌ์ผ ํ๊ณ ํ ๊ธ์๋ง ์
๋ ฅ๋ฐ์์ผํ๋ค.
๊ทธ๋ฆฌ๊ณ ๋์๋ฌธ์๋ ๊ด๊ณ ์์ด ์
๋ ฅ๋ ๊ฐ์ ๋๋ฌธ์๋ก ์นํํ ์๊ฐ์ด๋ค.
System.out.print("A-Z ์ค ํ๋๋ฅผ ์
๋ ฅํด์ฃผ์ธ์. : ");
String answer = sc.next().toUpperCase();
if(answer.length() != 1 || !Character.isLetter(answer.charAt(0))){
System.out.println("1๊ธ์์ ์ํ๋ฒณ๋ง ์
๋ ฅํด์ฃผ์ธ์.");
continue;
}
char inputLetter = answer.charAt(0);
Set<Character> usedLetters = new HashSet<>();
๋ฅผ ํ์ฉํ์ฌ ํ๋ ์ด์ด๊ฐ ์
๋ ฅํ ์ํ๋ฒณ์ ์ถ์ ํ๋ค. ์ด๋ฏธ ์
๋ ฅ๋ ์ํ๋ฒณ์ '์ด๋ฏธ ์
๋ ฅ ๋์๋ค'๊ณ ์๋ ค์ฃผ๊ณ
๊ธฐ์กด์ ์
๋ ฅ๋ ์ํ๋ฒณ์ด ์๋ ์ฒ์ ์
๋ ฅํ ์ํ๋ฒณ์ usedLetters
์ ์ถ๊ฐํ๋ค.
if (usedLetters.contains(inputLetter)) {
System.out.println("์ด๋ฏธ ์
๋ ฅํ ๋ฌธ์์
๋๋ค. ๋ค๋ฅธ ๋ฌธ์๋ฅผ ์
๋ ฅํด์ฃผ์ธ์.");
continue;
}
usedLetters.add(inputLetter);
๊ฒ์ฆ๊ณผ ์ถ์ ์ด ๋๋๋ฉด ํ๋ ์ด์ด๊ฐ ์
๋ ฅํ ์ํ๋ฒณ์ด ์ ๋ต์ผ๋ก ์ฃผ์ด์ง ๋จ์ด์ ํฌํจ ๋๋์ง
ํ์ธ์ ํด์ผํ๋ค. ์ด ๋ถ๋ถ์ ์กฐ๊ฑด์ผ๋ก ์ฌ์ฉํ ์๊ฐ์ด๋ค.
๊ทธ๋ฆฌ๊ณ ์ ๋ต ๋จ์ด์ ํ๋ ์ด์ด๊ฐ ์
๋ ฅํ ๋จ์ด๊ฐ ์์ผ๋ฉด for๋ฌธ
์ผ๋ก ์ ๋ต ๋จ์ด์ ๊ธธ์ด ๋งํผ Loop
๋ฅผ ๋๋ฉด์ currentGuessState
๋ฅผ ์
๋ฐ์ดํธ ํ๋ ค๊ณ ํ๋ค.
if(selectedWord.contains(String.valueOf(inputLetter))){
for (int i = 0; i < solutionWordArray.length; i++) {
if (solutionWordArray[i] == inputLetter) {
currentGuessState[i] = inputLetter; // ๋ง์ถ ๊ธ์๋ฅผ ๋ฐฐ์ด์ ๋ฐ์
}
}
}
๊ทธ ๋ค์ ์ ๋ต ๋จ์ด์ ํ๋ฆฐ ์ํ๋ฒณ์ ์
๋ ฅํ ๋๋ ํฌํจ๋์ง ์๋๋ค
๋ผ๊ณ ์๋ ค์ฃผ๊ณ
๊ธฐํ
๋ฅผ 1๊ฐ์ฉ ์์ง ์ํค๋ ค๊ณ ํ๋ค.
else {
System.out.println(inputLetter + "๋ ํฌํจ๋์ง ์์ต๋๋ค.");
count--;
}
์ด๋ ๊ฒ ๊ฒ์์ ์งํํ๋ฉด์ ์ ๋ต์ ๋ง์ถ ์ ์น๋ฆฌ!
๋ฅผ ํ์ํ๋ ์๋ด ๋ฉ์์ง๋ฅผ
while
๋ฌธ ๋งจ ์๋์ ์ฝ๋๋ฅผ ์์ฑํ๋ค. ์น๋ฆฌ ์ return
์ผ๋ก ๊ฒ์์ ์ข
๋ฃํ๋ค.
if(Arrays.equals(solutionWordArray, currentGuessState)){
System.out.println("์ถํํฉ๋๋ค. ์ ๋ต์ ๋ง์ถ์
จ์ต๋๋ค.");
System.out.println("์ ๋ต : " + String.valueOf(solutionWordArray));
return;
}
๊ฒ์์์ ํจ๋ฐฐํ ๋๋ while
๋ฌธ์ ๋น ์ ธ ๋์ค๋ ์ํฉ์ด๊ธฐ ๋๋ฌธ์
while
๋ฌธ ๋ฐ๊นฅ์ ๊ฒ์ ์ข
๋ฃ๋ฅผ ์๋ดํ๋ ๋ฉ์์ง๋ฅผ ์์ฑํ๋ค.
System.out.println("๊ธฐํ๋ฅผ ๋ชจ๋ ์ฌ์ฉํ์์ต๋๋ค.");
System.out.println("์ ๋ต์ " + String.valueOf(solutionWordArray) + "์
๋๋ค.");
import java.util.*;
public class GuessingWordGame {
public static void main(String[] args) {
Random random = new Random();
List<String> wordList = WordList.WORDS; // ๋จ์ด ๋ชจ์
int index = random.nextInt(wordList.size()); // ๋๋ค์ผ๋ก ๋ฝ์ ๋จ์ด ์ ์
String selectedWord = wordList.get(index).toUpperCase();
char[] solutionWordArray = selectedWord.toCharArray(); //๋ฝํ ๋จ์ด๋ฅผ ๋๋ฌธ์๋ก ์นํ
char[] currentGuessState = new char[solutionWordArray.length];
for (int i = 0; i < solutionWordArray.length; i++) {
currentGuessState[i] ='_';
}
int count = 9; // ๋จ์ ๊ธฐํ
Scanner sc = new Scanner(System.in); // ๋จ์ด ์
๋ ฅ๋ฐ๊ธฐ
//System.out.println(String.valueOf(solutionWordArray)); ์ ๋ต ํ์ธ์ฉ ํ
์คํธ
Set<Character> usedLetters = new HashSet<>();
System.out.println("๋จ์ด ๋ง์ถ๊ธฐ๋ฅผ ์์ํฉ๋๋ค. ๋ฌธ์ ๋ ์๋์ ๊ฐ์ต๋๋ค!");
while (count > 0){
System.out.println(String.valueOf(currentGuessState));
System.out.println("ํ์ฌ ๋จ์ ๊ธฐํ : " + count);
System.out.print("A-Z ์ค ํ๋๋ฅผ ์
๋ ฅํด์ฃผ์ธ์. : ");
String answer = sc.next().toUpperCase();
if(answer.length() != 1 || !Character.isLetter(answer.charAt(0))){
System.out.println("1๊ธ์์ ์ํ๋ฒณ๋ง ์
๋ ฅํด์ฃผ์ธ์.");
continue;
}
char inputLetter = answer.charAt(0);
if (usedLetters.contains(inputLetter)) {
System.out.println("์ด๋ฏธ ์
๋ ฅํ ๋ฌธ์์
๋๋ค. ๋ค๋ฅธ ๋ฌธ์๋ฅผ ์
๋ ฅํด์ฃผ์ธ์.");
continue;
}
usedLetters.add(inputLetter);
if(selectedWord.contains(String.valueOf(inputLetter))){
for (int i = 0; i < solutionWordArray.length; i++) {
if (solutionWordArray[i] == inputLetter) {
currentGuessState[i] = inputLetter; // ๋ง์ถ ๊ธ์๋ฅผ ๋ฐฐ์ด์ ๋ฐ์
}
}
}else {
System.out.println(inputLetter + "๋ ํฌํจ๋์ง ์์ต๋๋ค.");
count--;
}
if(Arrays.equals(solutionWordArray, currentGuessState)){
System.out.println("์ถํํฉ๋๋ค. ์ ๋ต์ ๋ง์ถ์
จ์ต๋๋ค.");
System.out.println("์ ๋ต : " + String.valueOf(solutionWordArray));
return;
}
}
System.out.println("๊ธฐํ๋ฅผ ๋ชจ๋ ์ฌ์ฉํ์์ต๋๋ค.");
System.out.println("์ ๋ต์ " + String.valueOf(solutionWordArray) + "์
๋๋ค.");
}
}
์๊ฐ๋ณด๋ค ์๊ฐํด์ผํ ๊ฒ๋ค์ด ๋ง์๋ค. ์๊ฐํ๋ ์๊ฐ์ ๋ณด๋์ผ๋ก์จ ํท๊ฐ๋ ธ๋ ๊ฒ๋ค๋ ์กฐ๊ธ์ฉ ์ดํด๊ฐ ๋๋ ๊ฒ ๊ฐ์ ์ข์๊ณ ํ๋ฒ์ ์๊ฐํ๊ธฐ ์ด๋ ค์ธ๋๋ ๋ฉ๋ชจ๋ฅผ ํ๊ณ ์กฐ๊ธ์ฉ ํ์ด๋๊ฐ๋ ๊ฒ์ด ๋ ์ข๊ฒ ๋ค ๋ผ๋๊ฑธ ๊นจ๋ฌ์๋ค.