Решение на Wordle от Искендер Чобанов

Обратно към всички решения

Към профила на Искендер Чобанов

Код

use std::fmt;

impl fmt::Display for Word {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

let mut string:String = "".to_string();

for (p,l) in self.get_input_word().chars().enumerate().collect::<Vec<(usize,char)>>()

{

let s = self.guess_letter_safe((p,&l));

match s

{

Letter::FullMatch(l) => string.push_str(&format!("[{}]",l.to_uppercase())),

Letter::PartialMatch(l) =>string.push_str(&format!("({})",l.to_uppercase())),

_=>string.push_str(&format!(">{}<",l.to_uppercase())),

}

}

return write!(f,"{}",&string);

}

}

impl fmt::Display for Game {

fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

let mut string:String = "".to_string();

// string.push_str("//");

for _z in self.word.word.chars()

{

string.push_str("|_|");

}

for i in &self.word_vec

{

string.push('\n');

// string.push_str("//");

string.push_str(&format!("{}",i));

}

write!{f,"{}",string}

}

}

#[derive(Debug)]

pub enum GameStatus {

InProgress,

Won,

Lost,

}

#[derive(Debug)]

pub enum GameError {

NotInAlphabet(char),

WrongLength { expected: usize, actual: usize },

GameIsOver(GameStatus),

EmptyWord,

}

#[derive(Debug)]

pub struct Game {

pub status: GameStatus,

pub attempts: u8,

pub max_attempts: u8,

alphabet: String,

word: Word,

word_vec: Vec<Word>

}

#[derive(Debug)]

pub struct Word {

pub word: String , //t e s t

pub input_word: String,

pub guessed: Vec<(usize,char)>,

pub p_guessed: Vec<char>,

// Каквито полета ви трябват

}

#[derive(Debug)]

pub enum Letter {

FullMatch(char),

PartialMatch(char),

NoMatch(char),

}

impl Word {

pub fn chars(&self)->std::str::Chars

{

return (&self.word).chars();

}

pub fn get_input_word(&self)->&str

{

&self.input_word[..]

}

pub fn set_input_word(&mut self,s:&str)

{

self.input_word = s.to_string();

}

pub fn new(s:&str)->Self {

let vec = Vec::<(usize,char)>::new();

let vec1 = Vec::<char>::new();

Self{word: s.to_string(),input_word:s.to_string(),guessed: vec,p_guessed: vec1}

}

pub fn is_win(&self)->bool

{

let a = self.word.chars().collect::<Vec<char>>();

a.len() == self.guessed.len()

}

pub fn guess_letter(&mut self,(p,c): (usize,&char))->Letter {

let c1 = *c;

let mut match_found = false;

let transform = self.word.chars().enumerate().collect::<Vec<(usize,char)>>();

for (a,b) in transform

{

if (p,c1) == (a,b)

{

let mut already_guessed=false;

for (e,f) in self.guessed.clone()

{

if (e,f)==(a,b)

{

already_guessed=true;

}

}

if !already_guessed

{self.guessed.push((p,c1));}

return Letter::FullMatch(c1);

}

if c1 == b

{

// println!("{:?}",self.p_guessed);

match_found = true;

}

}

if match_found

{

self.p_guessed.push(c1);

return Letter::PartialMatch(c1);

}

Letter::NoMatch(c1)

}

pub fn guess_letter_safe(&self,(p,c): (usize,&char))->Letter {

let c1 = *c;

let pg = self.p_guessed.clone();

//println!("{:?}+",pg);

let g = self.guessed.clone();

// println!("{:?}=",pg);

for (a,b) in g

{

// println!("{:?}",(a,b));

if (p,c1) == (a,b)

{

return Letter::FullMatch(c1);

}

}

for x in pg

{

if c1==x

{

return Letter::PartialMatch(c1);

}

}

Letter::NoMatch(c1)

}

}

impl Game {

/// Конструира нова игра с думи/букви от дадената в `alphabet` азбука. Alphabet е просто низ,

/// в който всеки символ е отделна буква, който вероятно искате да си запазите някак за после.

///

/// Подадената дума с `word` трябва да има само букви от тази азбука. Иначе очакваме да върнете

/// `GameError::NotInAlphabet` грешка с първия символ в `word`, който не е от азбуката.

///

/// Началното състояние на играта е `InProgress` а началния брой опити `attempts` е 0.

///

fn char_is_one_of(c: &char,s: &str) -> bool { //Checks if a single character is from a string (alphabet)

for ch in s.chars()

{

if ch == *c

{

return true;

}

}

false

}

pub fn word_is_over_alph(w: &str,a: &str)->Result<bool,GameError> {//Checks if all the characters of a word are from an alphabet

for cw in w.chars()

{

if !Self::char_is_one_of(&cw,a)

{

return Err(GameError::NotInAlphabet(cw));

}

}

Ok(true)

}

pub fn new(alphabet: &str, word: &str) -> Result<Self, GameError> {

//Condition for error:

if word == ""

{

return Err(GameError::EmptyWord);

}

else {

match Self::word_is_over_alph(word,alphabet){

Ok(true) => return Ok(Self{status: GameStatus::InProgress,attempts:0,max_attempts: 5,

alphabet: alphabet.to_string(),word: Word::new(word),word_vec: Vec::<Word>::new()}),

Ok(false) => unreachable!(),

Err(c) => return Err(c),

}; }

}

/// Опитва се да познае търсената дума. Опита е в `guess`.

///

/// Ако играта е приключила, тоест статуса ѝ е `Won` или `Lost`, очакваме да върнете

/// `GameIsOver` със статуса, с който е приключила.

///

/// Ако `guess` има различен брой букви от търсената дума, очакваме да върнете

/// `GameError::WrongLength`. Полето `expected` на грешката трябва да съдържа броя букви на

/// търсената дума, а `actual` да е броя букви на опита `guess`.

///

/// Ако `guess` има правилния брой букви, но има буква, която не е от азбуката на играта,

/// очакваме `GameError::NotInAlphabet` както по-горе, с първия символ от `guess`, който не е

/// от азбуката.

///

/// Метода приема `&mut self`, защото всеки опит се запазва в играта за по-нататък. Метода

/// връща `Word`, което описва освен самите символи на `guess`, и как тези символи са се

/// напаснали на търсената дума. Също така инкрементира `attempts` с 1.

///

/// След опита за напасване на думата, ако всички букви са уцелени на правилните места,

/// очакваме `state` полето да се промени на `Won`. Иначе, ако `attempts` са станали 5,

/// състоянието трябва да е `Lost`.

///

pub fn guess_word(&mut self, guess: &str) -> Result<Word, GameError> {

self.attempts+=1;

match self.status

{

GameStatus::InProgress => {},

GameStatus::Won => return Err(GameError::GameIsOver(GameStatus::Won)),

_ => return Err(GameError::GameIsOver(GameStatus::Lost))

}

match Self::word_is_over_alph(guess,&self.alphabet)

{

Err(err)=>Err(err),

Ok(false) => unreachable!(),

Ok(true) => {

let given=guess.chars().collect::<Vec<char>>().len();

let needed=self.word.chars().collect::<Vec<char>>().len();

if !(given == needed)

{

return Err(GameError::WrongLength { expected: needed, actual: given });

}

let mut vec_letters = Vec::<Letter>::new();

for (p,l) in guess.chars().enumerate().collect::<Vec<(usize,char)>>()

{

vec_letters.push(self.word.guess_letter((p,&l)));

}

if self.word.is_win()

{

self.status = GameStatus::Won;

}

if self.attempts==self.max_attempts

{

self.status = GameStatus::Lost;

}

let mut new_word = Word::new(&self.word.word);

new_word.set_input_word(guess);

new_word.guessed = self.word.guessed.to_vec();

new_word.p_guessed = self.word.p_guessed.to_vec();

let mut lazy_clone = Word::new(&self.word.word);

lazy_clone.set_input_word(guess);

lazy_clone.guessed = self.word.guessed.to_vec();

lazy_clone.p_guessed = self.word.p_guessed.to_vec();

self.word_vec.push(lazy_clone);

Ok(new_word)

}

}

}

}

#[test]

fn test_basic() {

{

let english_letters = "abcdefghijklmnopqrstuvwxyz";

// Конструираме по два различни начина, just in case -- няма причина да не работи и с двата.

assert!(Game::new(english_letters, "!!!").is_err());

let mut game = Game::new(&String::from(english_letters), "abc").unwrap();

assert!(matches!(game.status, GameStatus::InProgress));

assert_eq!(game.attempts, 0);

assert_eq!(game.to_string(), "|_||_||_|");

assert_eq!(game.guess_word("abc").unwrap().to_string(), "[A][B][C]");

}

{

let english_letters = "abcdefghijklmnopqrstuvwxyz";

// Конструираме по два различни начина, just in case -- няма причина да не работи и с двата.

assert!(matches!(Game::new(&String::from(english_letters), ""),Err(GameError::EmptyWord)));

assert!(matches!(Game::new("", "ba"),Err(GameError::NotInAlphabet('b'))));

}

}

#[test]

fn test_game_status() {

let english_letters = "abcdefghijklmnopqrstuvwxyz";

{

assert!(Game::new(english_letters, "!!!").is_err());

let mut game = Game::new(&String::from(english_letters), "abc").unwrap();

//Game loose condition + attempts checker

assert!(matches!(game.status, GameStatus::InProgress));

assert_eq!(game.attempts, 0);

game.guess_word("cba").unwrap().to_string();

assert!(matches!(game.status, GameStatus::InProgress));

assert_eq!(game.attempts, 1);

game.guess_word("bca").unwrap().to_string();

assert!(matches!(game.status, GameStatus::InProgress));

assert_eq!(game.attempts, 2);

game.guess_word("cba").unwrap().to_string();

assert!(matches!(game.status, GameStatus::InProgress));

assert_eq!(game.attempts, 3);

game.guess_word("aaa").unwrap().to_string();

assert!(matches!(game.status, GameStatus::InProgress));

assert_eq!(game.attempts, 4);

game.guess_word("bbb").unwrap().to_string();

assert!(matches!(game.status, GameStatus::Lost));

assert_eq!(game.attempts, 5);

assert!(matches!(game.guess_word("bab"), Err(GameError::GameIsOver(GameStatus::Lost))));

}

{ //Game win condition

let mut game = Game::new(&String::from(english_letters), "abc").unwrap();

assert!(matches!(game.status, GameStatus::InProgress));

assert_eq!(game.attempts, 0);

game.guess_word("abc").unwrap().to_string();

assert!(matches!(game.status, GameStatus::Won));

assert_eq!(game.attempts, 1);

assert!(matches!(game.guess_word("bab"), Err(GameError::GameIsOver(GameStatus::Won))));

}

}

#[test]

fn test_game_other_errors() {

let english_letters = "abcdefghijklmnopqrstuvwxyz";

let mut game = Game::new(&String::from(english_letters), "abc").unwrap();

assert!(matches!(game.guess_word("baba"), Err(GameError::WrongLength{expected: 3,actual: 4})));

assert!(matches!(game.guess_word("буу"), Err(GameError::NotInAlphabet('б'))));

assert!(matches!(game.guess_word("bуo"), Err(GameError::NotInAlphabet('у'))));

}

#[test]

fn test_duplicates_and_non_ascii() {

{

let english_letters = "abcdefghijklmnopqrstuvwxyz";

let mut game = Game::new(&String::from(english_letters), "foobar").unwrap();

assert_eq!(game.guess_word("oopsie").unwrap().to_string(),"(O)[O]>P<>S<>I<>E<");

}

{

let german_letters = "abcdefghijklmnopqrstuvwxyzäöüß";

let mut game = Game::new(german_letters, "süß").unwrap();

assert_eq!(game.guess_word("füß").unwrap().to_string(),">F<[Ü][SS]");

}

{

let english_letters = "abcdefghijklmnopqrstuvwxyz";

let mut game = Game::new(english_letters, "banal").unwrap();

assert_eq!(game.guess_word("alloy").unwrap().to_string(),"(A)(L)(L)>O<>Y<");

//what if you guess a letter more times than the original word?

}

{

let greek_letters = "αβγξπφ";

let mut game = Game::new(greek_letters, "γαπβα").unwrap();

assert_eq!(game.guess_word("γαβαα").unwrap().to_string(),"[Γ][Α](Β)(Α)[Α]");

//what if you guess a letter more times than the original word?

}

}

Лог от изпълнението

Compiling solution v0.1.0 (/tmp/d20230111-3772066-1m8wm1n/solution)
    Finished test [unoptimized + debuginfo] target(s) in 0.88s
     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 ... ok
test solution_test::test_game_display_german ... ok
test solution_test::test_game_state_1 ... ok
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_german ... ok
test solution_test::test_word_display_bulgarian ... ok
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 ... ok
test solution_test::test_wrong_length ... FAILED

failures:

---- solution_test::test_wrong_length stdout ----
thread 'solution_test::test_wrong_length' panicked at 'Expression Err(NotInAlphabet(' ')) does not match the pattern "Err(GameError::WrongLength { expected: 4, actual: 5 })"', tests/solution_test.rs:98:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    solution_test::test_wrong_length

test result: FAILED. 14 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--test solution_test`

История (2 версии и 1 коментар)