Решение на Wordle от Йордан Илиев
Резултати
- 15 точки от тестове
- 0 бонус точки
- 15 точки общо
- 11 успешни тест(а)
- 4 неуспешни тест(а)
Код
use std::fmt;
#[derive(Debug)]
#[derive(Clone, Copy)]
#[derive(PartialEq)]
pub enum GameStatus {
InProgress,
Won,
Lost
}
#[derive(Debug)]
pub enum GameError {
NotInAlphabet(char),
WrongLength { expected: usize, actual: usize },
GameIsOver(GameStatus)
}
#[derive(Debug)]
pub struct Game {
pub status: GameStatus,
pub attempts: u8,
alphabet: String,
word: String,
pub attempt_history: Vec<Word>
}
#[derive(Debug)]
#[derive(Clone)]
pub struct Word {
letters: Vec<GuessLetter>
}
#[derive(Debug)]
#[derive(Clone, Copy)]
enum GuessLetter {
CorrectPosition(char),
WrongPosition(char),
NoOccurances(char)
}
impl fmt::Display for GuessLetter {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let res =match self {
GuessLetter::CorrectPosition(letter) =>
format!("[{}]", GuessLetter::format_letter(letter)),
GuessLetter::WrongPosition(letter) =>
format!("({})", GuessLetter::format_letter(letter)),
GuessLetter::NoOccurances(letter) =>
format!(">{}<", GuessLetter::format_letter(letter)),
};
write!(f, "{}", res)
}
}
impl fmt::Display for Word {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for letter in &self.letters {
write!(f, "{}", letter)?;
}
Ok(())
}
}
impl fmt::Display for Game {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
for _ in 0..self.word.len() {
write!(f, "|_|")?;
}
for word in &self.attempt_history {
write!(f, "\n{}", word)?;
}
Ok(())
}
}
impl GuessLetter {
fn format_letter(letter: &char) -> String {
letter.to_uppercase().to_string()
}
}
impl Word {
pub fn from_guess(guess: &str, word: &str) -> Self {
let mut result: Vec<GuessLetter> = Vec::new();
// TODO: Maybe rewrite it with map + collect
for (index, letter) in guess.chars().enumerate() {
// TODO: should verify that word.len() = guess.len()
// which is currently always true, but yea vvvvvvvvv
let guess_letter = if word.chars().nth(index).unwrap() == letter {
GuessLetter::CorrectPosition(letter)
} else if word.contains(letter) {
GuessLetter::WrongPosition(letter)
} else {
GuessLetter::NoOccurances(letter)
};
result.push(guess_letter)
}
Word { letters: result }
}
}
impl Game {
pub fn new(alphabet: &str, word: &str) -> Result<Self, GameError> {
Game::validate_word_in_alphabet(alphabet, word)?;
Ok(Game {
status: GameStatus::InProgress,
attempts: 0,
alphabet: String::from(alphabet),
word: String::from(word),
attempt_history: Vec::new()
})
}
pub fn guess_word(&mut self, guess: &str) -> Result<Word, GameError> {
self.validate_game_is_active()?;
self.validate_guess_length(guess)?;
Game::validate_word_in_alphabet(&self.alphabet, guess)?;
let current_guess_result = Word::from_guess(guess, &self.word);
self.attempt_history.push(current_guess_result.clone());
self.attempts += 1;
if guess == self.word {
self.status = GameStatus::Won;
} else if self.attempts == 5 {
self.status = GameStatus::Lost;
}
Ok(current_guess_result.clone())
}
fn validate_guess_length(& self, guess: &str) -> Result<(), GameError> {
if self.word.len() != guess.len() {
Err(GameError::WrongLength { expected: self.word.len(), actual: guess.len() })
}
else { Ok(()) }
}
fn validate_word_in_alphabet(alphabet: &str, word: &str) -> Result<(), GameError> {
let maybe_letter = word.chars().into_iter()
.find(|&letter| { !alphabet.contains(letter) });
match maybe_letter {
Some(letter) => Err(GameError::NotInAlphabet(letter)),
None => Ok(()),
}
}
fn validate_game_is_active(&self) -> Result<(), GameError> {
if self.status != GameStatus::InProgress {
Err(GameError::GameIsOver(self.status))
}
else {
Ok(())
}
}
}
Лог от изпълнението
Compiling solution v0.1.0 (/tmp/d20230111-3772066-191v0tc/solution)
Finished test [unoptimized + debuginfo] target(s) in 0.90s
Running tests/solution_test.rs (target/debug/deps/solution_test-0edbea2040daef01)
running 15 tests
test solution_test::test_game_display ... ok
test solution_test::test_game_display_cyrillic ... FAILED
test solution_test::test_game_state_1 ... ok
test solution_test::test_game_display_german ... FAILED
test solution_test::test_game_state_2 ... ok
test solution_test::test_game_state_3 ... ok
test solution_test::test_word_display ... ok
test solution_test::test_word_display_bulgarian ... ok
test solution_test::test_word_display_german ... FAILED
test solution_test::test_word_display_with_repetitions ... ok
test solution_test::test_word_not_in_alphabet_on_construction ... ok
test solution_test::test_word_not_in_alphabet_on_construction_cyrrilic ... ok
test solution_test::test_word_not_in_alphabet_on_guess ... ok
test solution_test::test_word_not_in_alphabet_on_guess_cyrillic ... FAILED
test solution_test::test_wrong_length ... ok
failures:
---- solution_test::test_game_display_cyrillic stdout ----
thread 'solution_test::test_game_display_cyrillic' panicked at 'assertion failed: `(left == right)`
left: `"|_||_||_||_||_||_|"`,
right: `"|_||_||_|"`', tests/solution_test.rs:119:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- solution_test::test_game_display_german stdout ----
thread 'solution_test::test_game_display_german' panicked at 'assertion failed: `(left == right)`
left: `"|_||_||_||_||_|"`,
right: `"|_||_||_|"`', tests/solution_test.rs:133:5
---- solution_test::test_word_display_german stdout ----
thread 'solution_test::test_word_display_german' panicked at 'assertion failed: `(left == right)`
left: `"|_||_||_||_||_|"`,
right: `"|_||_||_|"`', tests/solution_test.rs:87:5
---- solution_test::test_word_not_in_alphabet_on_guess_cyrillic stdout ----
thread 'solution_test::test_word_not_in_alphabet_on_guess_cyrillic' panicked at 'Expression Err(WrongLength { expected: 4, actual: 8 }) does not match the pattern "Err(GameError::NotInAlphabet('х'))"', tests/solution_test.rs:46:5
failures:
solution_test::test_game_display_cyrillic
solution_test::test_game_display_german
solution_test::test_word_display_german
solution_test::test_word_not_in_alphabet_on_guess_cyrillic
test result: FAILED. 11 passed; 4 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass `--test solution_test`