Програмиране с Rust

Курс във Факултета по Математика и Информатика към СУ

Dungeon Map

Краен срок
20.01.2022 17:00
Точки
4

Срокът за предаване на решения е отминал

use solution::*;
#[test]
fn test_basic() {
let room = Room {
name: String::from("Living Room"),
north: String::from("Balcony"),
south: String::from("Bathroom"),
east: String::from("Kitchen"),
west: String::from("Entrance"),
};
let expected = "
[ Balcony ]
|
+------N------+
Entrance - | Living Room | - Kitchen
+------S------+
|
[ Bathroom ]";
assert_eq!(format!("{}", room), expected);
}
#[test]
fn test_cyrillic() {
let room = Room {
name: String::from("Дневна"),
north: String::from("Тераса"),
south: String::from("Баня"),
east: String::from("Кухня"),
west: String::from("Вход"),
};
let expected = "
[ Тераса ]
|
+----N----+
Вход - | Дневна | - Кухня
+----S----+
|
[ Баня ]";
assert_eq!(format!("{}", room), expected);
}
#[test]
fn test_short() {
let room = Room {
name: String::from("X"),
north: String::from("N"),
south: String::from("S"),
east: String::from("E"),
west: String::from("W"),
};
let expected = "
[ N ]
|
+-N-+
W - | X | - E
+-S-+
|
[ S ]";
assert_eq!(format!("{}", room), expected);
}

Някой в един момент попита дали ще има Display на стаите в dungeon-а от домашно 3. So why not.

Ще очакваме в домашното да дефинирате структура Room, която изглежда така:

pub struct Room {
    pub name: String,
    pub north: String,
    pub south: String,
    pub east: String,
    pub west: String,
}

Дефинирайте Display имплементация, която да позволи да визуализираме стая и съседите ѝ:

let room = Room {
    name: String::from("Living Room"),
    north: String::from("Balcony"),
    south: String::from("Bathroom"),
    east: String::from("Kitchen"),
    west: String::from("Entrance"),
};

println!("{}", room);

Изхода би трябвало да изглежда така:

           [   Balcony   ]
                  |
           +------N------+
Entrance - | Living Room | - Kitchen
           +------S------+
                  |
           [  Bathroom   ]

Ето и още един пример с различна стая:

       [ Тераса  ]
            |
       +----N----+
Вход - | Дневна  | - Кухня
       +----S----+
            |
       [  Баня   ]

Да минем през правилата:

  • Името на стаята е оградено от кутийка, която има + символи в ъглите и N и S отгоре и отдолу, центрирани в страните на кутията. Ако името на стаята има четен брой символи като "Дневна", добавете един интервал накрая, за да се получи нечетен (за да може N и S да бъдат винаги точно по средата).
  • Същото се отнася за центрирането на северната и южната стая -- ако "центъра" е между два символа, приемете, че има извънреден интервал отдясно. При центрирането на "Баня", чертичката е над "н"-то а не над "а"-то.
  • Квадратните скоби ([]) са подравнени със стените на кутийката на стаята. Може да приемете, че нито северната, нито южната стая няма да бъдат по-дълги от името name -- няма да тестваме с такива примери. (Ако искате да си имплементирате този случай, вариант е да отрежете твърде-дълги имена, също както е вариант да изберете максималната дължина между трите за обща.)
  • Също приемете, че няма да тестваме с празни низове за стаи.
  • Очакваме да няма trailing whitespace след текста. Тоест, ако намерите начин някъде из стандартната библиотека за центриране, супер, но имайте предвид че "центриране" означава padding с интервали и отдясно, което ще fail-не теста по-долу.
  • Първия написан символ очакваме да е точно един нов ред (символ \n). За да може ако печатаме с println!, да се подсигурим че ще започне на нов ред. Накрая на низа обаче не се output-ва нов ред -- println! би напечатал. Теста по-долу би трябвало да ви минава, basically.
#[test]
fn test_short() {
    let room = Room {
        name: String::from("X"),
        north: String::from("N"),
        south: String::from("S"),
        east: String::from("E"),
        west: String::from("W"),
    };

    let expected = "
    [ N ]
      |
    +-N-+
W - | X | - E
    +-S-+
      |
    [ S ]";

    assert_eq!(format!("{}", room), expected);
}

Както винаги, предизвикателството е "всичко или нищо", така че тествайте внимателно. Задачата не би трябвало да съдържа нещо сложно откъм Rust features, но за сметка на това има потенциала да е досадна работата по центриране и off-by-one errors. Но затова е за бонус точки, все пак -- имате позволението ни да се откажете от човъркането в един момент и да се концентрирате върху проектите си :).

За extra hard mode, опитайте се да минимизирате string allocations и кода да е ясен и прост. Няма да получите бонус точки, но може да ви донесе морално удовлетворение (ако успеете).

Решения

Андрей
  • Коректно
  • 3 успешни тест(а)
  • 0 неуспешни тест(а)
Андрей

use std::fmt;
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
impl fmt::Display for Room {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let middle_left = format!("{} - |", self.west);
let middle_left_len = middle_left.chars().count();
let (name, name_len) = pad_odd(&self.name);
let (north, _) = pad_odd(&self.north);
let (south, _) = pad_odd(&self.south);
let middle = format!("{} {} | - {}", middle_left, name, self.east);
let north_roof = format!("+{:-^len$}+", "N", len = name_len + 2);
let south_roof = format!("+{:-^len$}+", "S", len = name_len + 2);
let roof_offset = " ".repeat(middle_left_len - 1);
let pipe_offset = " ".repeat(roof_offset.len() + north_roof.len() / 2);
let inner_roof_width = north_roof.len() - 2;
// Use new format strings syntax: https://blog.rust-lang.org/2022/01/13/Rust-1.58.0.html
writeln!(f)?;
writeln!(f, "{roof_offset}[{north:^inner_roof_width$}]")?;
writeln!(f, "{pipe_offset}|")?;
writeln!(f, "{roof_offset}{north_roof}")?;
writeln!(f, "{middle}")?;
writeln!(f, "{roof_offset}{south_roof}")?;
writeln!(f, "{pipe_offset}|")?;
write!(f, "{roof_offset}[{south:^inner_roof_width$}]")?;
Ok(())
}
}
fn pad_odd(input: &str) -> (String, usize) {
let char_count = input.chars().count();
if char_count % 2 == 0 {
(format!("{} ", input), char_count + 1)
} else {
(input.to_owned(), char_count)
}
} 
Compiling solution v0.1.0 (/tmp/d20220120-3533338-1xbx8ro/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.97s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... ok
test solution_test::test_short ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Павел Сарлов
  • Коректно
  • 3 успешни тест(а)
  • 0 неуспешни тест(а)
Павел Сарлов

use std::fmt;
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
impl fmt::Display for Room {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
writeln!(f)?;
let center_count = usize::max(self.south.chars().count(), usize::max(self.name.chars().count(), self.north.chars().count()));
let padding_left = self.west.chars().count() + 3;
let box_width = center_count + 2 + (center_count + 1) % 2;
writeln!(f, "{:>padding_left$}[{:^box_width$}]", "", self.north, padding_left = padding_left, box_width = box_width)?;
writeln!(f, "{:>padding_left$}{}", "", "|", padding_left = padding_left + box_width / 2 + 1)?;
writeln!(f, "{:>padding_left$}+{:-^box_width$}+", "", "N", padding_left = padding_left, box_width = box_width)?;
writeln!(f, "{} - |{:^box_width$}| - {}", self.west, self.name, self.east, box_width = box_width)?;
writeln!(f, "{:>padding_left$}+{:-^box_width$}+", "", "S", padding_left = padding_left, box_width = box_width)?;
writeln!(f, "{:>padding_left$}{}", "", "|", padding_left = padding_left + box_width / 2 + 1)?;
write!(f, "{:>padding_left$}[{:^box_width$}]", "", self.south, padding_left = padding_left, box_width = box_width)?;
Ok(())
}
}
#[cfg(test)]
mod custom_tests {
use super::*;
#[test]
fn test1() {
let room = Room {
name: String::from("Living Room"),
north: String::from("Balcony"),
south: String::from("Bathroom"),
east: String::from("Kitchen"),
west: String::from("Entrance"),
};
let expected = "
[ Balcony ]
|
+------N------+
Entrance - | Living Room | - Kitchen
+------S------+
|
[ Bathroom ]";
assert_eq!(format!("{}", room), expected);
}
#[test]
fn test2() {
let room = Room {
name: String::from("Дневна"),
north: String::from("Тераса"),
south: String::from("Баня"),
east: String::from("Кухня"),
west: String::from("Вход"),
};
let expected = "
[ Тераса ]
|
+----N----+
Вход - | Дневна | - Кухня
+----S----+
|
[ Баня ]";
assert_eq!(format!("{}", room), expected);
}
}
Compiling solution v0.1.0 (/tmp/d20220120-3533338-173z0l0/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.63s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... ok
test solution_test::test_short ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Петър Ангелов
  • Коректно
  • 3 успешни тест(а)
  • 0 неуспешни тест(а)
Петър Ангелов

use std::fmt;
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
impl fmt::Display for Room {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let west_len = self.west.chars().count();
let north_len = self.north.chars().count();
let south_len = self.south.chars().count();
let name_len = self.name.chars().count();
let left_center = west_len + 3;
let pad_center = 1 - name_len % 2;
let right_center = left_center + name_len + 3 + pad_center;
let center = left_center + (right_center - left_center) / 2;
let north_start = left_center + (right_center - left_center - north_len + 1) / 2;
let south_start = left_center + (right_center - left_center - south_len + 1) / 2;
let between_line = format!("{}|\n", " ".repeat(center));
let left_pad = " ".repeat(left_center);
let n_s_line_beggining = format!("{}+{}", left_pad, "-".repeat(center - left_center - 1));
let n_s_line_pad = "-".repeat(right_center - center - 1);
// empty line
write!(f, "\n")?;
// first line
write!(
f,
"{}[ {}{}{} ]\n",
left_pad,
" ".repeat(north_start - left_center - 2),
self.north,
" ".repeat(right_center - north_start - north_len - 1)
)?;
// second line
write!(f, "{}", between_line)?;
// third line
write!(f, "{}N{}+\n", n_s_line_beggining, n_s_line_pad)?;
// fourth line
write!(
f,
"{} - | {}{} | - {}\n",
self.west,
self.name,
" ".repeat(pad_center),
self.east
)?;
// fifth line
write!(f, "{}S{}+\n", n_s_line_beggining, n_s_line_pad)?;
// sixth line
write!(f, "{}", between_line)?;
// seventh line
write!(
f,
"{}[ {}{}{} ]",
left_pad,
" ".repeat(south_start - left_center - 2),
self.south,
" ".repeat(right_center - south_start - south_len - 1)
)
}
} 
Compiling solution v0.1.0 (/tmp/d20220120-3533338-ibd1xr/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.58s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... ok
test solution_test::test_short ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Георги Попов
  • Коректно
  • 3 успешни тест(а)
  • 0 неуспешни тест(а)
Георги Попов

use std::fmt;
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
impl fmt::Display for Room {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut fixed_name: String = fix_room_name(self.name.clone());
let mut fixed_north: String = fix_room_name(self.north.clone());
let mut fixed_south: String = fix_room_name(self.south.clone());
let nestho = format!("{} - | {} | - {}", self.west, fixed_name, self.east);
let nRow = form_row(
fixed_name.chars().count() + 2,
'N',
self.west.chars().count() + 3,
);
let sRow = form_row(
fixed_name.chars().count() + 2,
'S',
self.west.chars().count() + 3,
);
let fB = form_begin_f_l_row(
(fixed_name.chars().count() / 2) - (fixed_north.chars().count() / 2) + 1,
self.west.chars().count() + 3,
);
let fA = form_after_f_l_row(
(fixed_name.chars().count() / 2) - (fixed_north.chars().count() / 2) + 1,
);
let lB = form_begin_f_l_row(
(fixed_name.chars().count() / 2) - (fixed_south.chars().count() / 2) + 1,
self.west.chars().count() + 3,
);
let lA = form_after_f_l_row(
(fixed_name.chars().count() / 2) - (fixed_south.chars().count() / 2) + 1,
);
let emptyRow =
form_empty_row(self.west.chars().count() + (fixed_name.chars().count() / 2) + 5);
write!(
f,
"\n{}{}{}\n{}\n{}\n{}\n{}\n{}\n{}{}{}",
fB, fixed_north, fA, emptyRow, nRow, nestho, sRow, emptyRow, lB, fixed_south, lA,
)
}
}
fn fix_room_name(name: String) -> String {
let mut new_name = name;
if new_name.len() % 2 == 0 {
new_name.push(' ');
}
return new_name;
}
fn form_row(len: usize, symbol: char, len_before: usize) -> String {
let mut result = String::new();
let mut iter = 0;
while iter < len_before {
result.push(' ');
iter += 1;
}
result.push('+');
let mut iter = 0;
while iter < len {
if iter == len / 2 {
result.push(symbol);
} else {
result.push('-')
}
iter += 1;
}
result.push('+');
return result;
}
fn form_empty_row(len: usize) -> String {
let mut result = String::new();
let mut iter = 0;
while iter < len {
result.push(' ');
iter += 1;
}
result.push('|');
result
}
fn form_begin_f_l_row(len: usize, len_before: usize) -> String {
let mut result = String::new();
let mut iter = 0;
while iter < len_before {
result.push(' ');
iter += 1;
}
result.push('[');
let mut iter = 0;
while iter < len {
result.push(' ');
iter += 1;
}
result
}
fn form_after_f_l_row(len: usize) -> String {
let mut result = String::new();
let mut iter = 0;
while iter < len {
result.push(' ');
iter += 1;
}
result.push(']');
result
} 
Compiling solution v0.1.0 (/tmp/d20220120-3533338-1b00rpb/solution)
warning: variable does not need to be mutable
  --> src/lib.rs:12:13
   |
12 |         let mut fixed_name: String = fix_room_name(self.name.clone());
   |             ----^^^^^^^^^^
   |             |
   |             help: remove this `mut`
   |
   = note: `#[warn(unused_mut)]` on by default

warning: variable does not need to be mutable
  --> src/lib.rs:13:13
   |
13 |         let mut fixed_north: String = fix_room_name(self.north.clone());
   |             ----^^^^^^^^^^^
   |             |
   |             help: remove this `mut`

warning: variable does not need to be mutable
  --> src/lib.rs:14:13
   |
14 |         let mut fixed_south: String = fix_room_name(self.south.clone());
   |             ----^^^^^^^^^^^
   |             |
   |             help: remove this `mut`

warning: variable `nRow` should have a snake case name
  --> src/lib.rs:17:13
   |
17 |         let nRow = form_row(
   |             ^^^^ help: convert the identifier to snake case: `n_row`
   |
   = note: `#[warn(non_snake_case)]` on by default

warning: variable `sRow` should have a snake case name
  --> src/lib.rs:22:13
   |
22 |         let sRow = form_row(
   |             ^^^^ help: convert the identifier to snake case: `s_row`

warning: variable `fB` should have a snake case name
  --> src/lib.rs:28:13
   |
28 |         let fB = form_begin_f_l_row(
   |             ^^ help: convert the identifier to snake case: `f_b`

warning: variable `fA` should have a snake case name
  --> src/lib.rs:32:13
   |
32 |         let fA = form_after_f_l_row(
   |             ^^ help: convert the identifier to snake case: `f_a`

warning: variable `lB` should have a snake case name
  --> src/lib.rs:36:13
   |
36 |         let lB = form_begin_f_l_row(
   |             ^^ help: convert the identifier to snake case: `l_b`

warning: variable `lA` should have a snake case name
  --> src/lib.rs:40:13
   |
40 |         let lA = form_after_f_l_row(
   |             ^^ help: convert the identifier to snake case: `l_a`

warning: variable `emptyRow` should have a snake case name
  --> src/lib.rs:44:13
   |
44 |         let emptyRow =
   |             ^^^^^^^^ help: convert the identifier to snake case: `empty_row`

warning: `solution` (lib) generated 10 warnings
    Finished test [unoptimized + debuginfo] target(s) in 1.57s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... ok
test solution_test::test_short ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Мирослав Дионисиев
  • Некоректно
  • 2 успешни тест(а)
  • 1 неуспешни тест(а)
Мирослав Дионисиев

use std::{fmt, io::repeat};
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_short() {
let room = Room {
name: String::from("X"),
north: String::from("N"),
south: String::from("S"),
east: String::from("E"),
west: String::from("W"),
};
let expected = "
[ N ]
|
+-N-+
W - | X | - E
+-S-+
|
[ S ]";
assert_eq!(format!("{}", room), expected);
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
impl fmt::Display for Room
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result
{
let lenght_left = self.west.len() + " - ".len();
let mut lenght_name_box = self.name.len() + "| |".len();
let mut res:String = String::from("\n");
let mut room = self.west.chars().collect::<Vec<char>>();
room.append(&mut " - | ".chars().collect::<Vec<char>>());
room.append(&mut self.name.chars().collect::<Vec<char>>());
if self.name.len()%2==0
{
room.push(' ');
lenght_name_box+=1;
}
room.append(&mut " | - ".chars().collect::<Vec<char>>());
room.append(&mut self.east.chars().collect::<Vec<char>>());
room.push('\n');
let spaces_left = std::iter::repeat(' ').take(lenght_left).collect::<Vec<char>>();
let mut dashes = std::iter::repeat('-').take(lenght_name_box/2 - 1).collect::<Vec<char>>();
let mut room_north = spaces_left.clone();
room_north.append(&mut "[".chars().collect::<Vec<char>>());
room_north.append(&mut std::iter::repeat(' ').take((lenght_name_box - 2 - self.north.len())/2).collect::<Vec<char>>());
room_north.append(&mut self.north.chars().collect::<Vec<char>>());
if self.north.len()%2==0
{
room_north.push(' ');
}
room_north.append(&mut std::iter::repeat(' ').take((lenght_name_box - 2 - self.north.len())/2).collect::<Vec<char>>());
room_north.append(&mut "]\n".chars().collect::<Vec<char>>());
let word = room_north.iter().collect::<String>();
res.push_str(&word);
let mut connector = std::iter::repeat(' ').take(lenght_left + lenght_name_box/2).collect::<Vec<char>>();
connector.push('|');
connector.push('\n');
let word = connector.iter().collect::<String>();
res.push_str(&word);
let mut north = spaces_left.clone();
north.push('+');
north.append(&mut dashes.clone());
north.push('N');
north.append(&mut dashes.clone());
north.push('+');
north.push('\n');
let word = north.iter().collect::<String>();
res.push_str(&word);
let word = room.iter().collect::<String>();
res.push_str(&word);
let mut south = spaces_left.clone();
south.push('+');
south.append(&mut dashes.clone());
south.push('S');
south.append(&mut dashes.clone());
south.push('+');
south.push('\n');
let word = south.iter().collect::<String>();
res.push_str(&word);
let word = connector.iter().collect::<String>();
res.push_str(&word);
let mut room_south = spaces_left.clone();
room_south.append(&mut "[".chars().collect::<Vec<char>>());
room_south.append(&mut std::iter::repeat(' ').take((lenght_name_box - 2 - self.south.len())/2).collect::<Vec<char>>());
room_south.append(&mut self.south.chars().collect::<Vec<char>>());
if self.south.len()%2==0
{
room_south.push(' ');
}
room_south.append(&mut std::iter::repeat(' ').take((lenght_name_box - 2 - self.south.len())/2).collect::<Vec<char>>());
room_south.append(&mut "]".chars().collect::<Vec<char>>());
let word = room_south.iter().collect::<String>();
res.push_str(&word);
write!(f, "{}", res)
}
}
Compiling solution v0.1.0 (/tmp/d20220120-3533338-19bazd0/solution)
warning: unused import: `io::repeat`
 --> src/lib.rs:1:16
  |
1 | use std::{fmt, io::repeat};
  |                ^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: variable does not need to be mutable
  --> src/lib.rs:59:13
   |
59 |         let mut dashes = std::iter::repeat('-').take(lenght_name_box/2 - 1).collect::<Vec<char>>();
   |             ----^^^^^^
   |             |
   |             help: remove this `mut`
   |
   = note: `#[warn(unused_mut)]` on by default

warning: `solution` (lib) generated 2 warnings
    Finished test [unoptimized + debuginfo] target(s) in 1.75s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... FAILED
test solution_test::test_short ... ok

failures:

---- solution_test::test_cyrillic stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `"\n           [ Тераса  ]\n                   |\n           +-------N-------+\nВход - | Дневна  | - Кухня\n           +-------S-------+\n                   |\n           [   Баня    ]"`,
 right: `"\n       [ Тераса  ]\n            |\n       +----N----+\nВход - | Дневна  | - Кухня\n       +----S----+\n            |\n       [  Баня   ]"`', tests/solution_test.rs:45:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    solution_test::test_cyrillic

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

error: test failed, to rerun pass '--test solution_test'
Павел Атанасов
  • Коректно
  • 3 успешни тест(а)
  • 0 неуспешни тест(а)
Павел Атанасов

use std::fmt::{Display, Formatter};
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
macro_rules! max {
{
$type: ty | $( $element: expr ),* $(,)?
} => {{
let mut max: $type = <$type>::MIN;
$( max = std::cmp::max(max, $element); )*
max
}}
}
enum HorizontalDirection {
Left,
Right,
}
enum VerticalDirection {
North,
South,
}
fn inner_offset(max_size: usize, word_length: usize, direction: HorizontalDirection) -> String {
" ".repeat(match direction {
HorizontalDirection::Left => (max_size - word_length) / 2,
HorizontalDirection::Right => (max_size - word_length) / 2 + (1 - word_length % 2),
})
}
impl Display for Room {
fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
let name_length = self.name.chars().count();
let north_length = self.north.chars().count();
let south_length = self.south.chars().count();
// let east_length = self.east.chars().count();
let west_length = self.west.chars().count();
let biggest_middle_length = max!(usize | north_length, name_length, south_length);
let middle_inner_size = 2 + biggest_middle_length + (1 - biggest_middle_length % 2); // 2(+1) for spaces
let middle_outer_size = 2 + middle_inner_size; // 2 for edges
let left_offset_spaces = " ".repeat(west_length + 3); // 3 for ' - '
let middle_outer_spaces = " ".repeat(middle_outer_size / 2);
let middle_inner_dashes = "-".repeat(middle_inner_size / 2);
let vertical_room = |formatter: &mut Formatter<'_>,
vertical_direction: VerticalDirection|
-> std::fmt::Result {
write!(
formatter,
"\n{}[{}{}{}]",
left_offset_spaces,
inner_offset(
middle_inner_size,
match vertical_direction {
VerticalDirection::North => north_length,
VerticalDirection::South => south_length,
},
HorizontalDirection::Left
),
match vertical_direction {
VerticalDirection::North => &self.north,
VerticalDirection::South => &self.south,
},
inner_offset(
middle_inner_size,
match vertical_direction {
VerticalDirection::North => north_length,
VerticalDirection::South => south_length,
},
HorizontalDirection::Right
),
)
};
let vertical_corridor = |formatter: &mut Formatter<'_>| -> std::fmt::Result {
write!(
formatter,
"\n{}{}|",
left_offset_spaces, middle_outer_spaces,
)
};
let middle_edge = |formatter: &mut Formatter<'_>,
vertical_direction: VerticalDirection|
-> std::fmt::Result {
write!(
formatter,
"\n{}+{}{}{}+",
left_offset_spaces,
middle_inner_dashes,
match vertical_direction {
VerticalDirection::North => "N",
VerticalDirection::South => "S",
},
middle_inner_dashes,
)
};
let middle_room = |formatter: &mut Formatter<'_>| -> std::fmt::Result {
write!(
formatter,
"\n{} - |{}{}{}| - {}",
&self.west,
inner_offset(middle_inner_size, name_length, HorizontalDirection::Left), // always 1
&self.name,
inner_offset(middle_inner_size, name_length, HorizontalDirection::Right), // 1 or 2
&self.east,
)
};
vertical_room(formatter, VerticalDirection::North)?;
vertical_corridor(formatter)?;
middle_edge(formatter, VerticalDirection::North)?;
middle_room(formatter)?;
middle_edge(formatter, VerticalDirection::South)?;
vertical_corridor(formatter)?;
vertical_room(formatter, VerticalDirection::South)?;
Ok(())
}
}
#[cfg(test)]
mod tests {
use crate::*;
#[test]
fn test_english() {
let room = Room {
name: String::from("Living Room"),
north: String::from("Balcony"),
south: String::from("Bathroom"),
east: String::from("Kitchen"),
west: String::from("Entrance"),
};
let expected = "
[ Balcony ]
|
+------N------+
Entrance - | Living Room | - Kitchen
+------S------+
|
[ Bathroom ]";
assert_eq!(format!("{}", room), expected);
}
#[test]
fn test_cyrillic() {
let room = Room {
name: String::from("Дневна"),
north: String::from("Тераса"),
south: String::from("Баня"),
east: String::from("Кухня"),
west: String::from("Вход"),
};
let expected = "
[ Тераса ]
|
+----N----+
Вход - | Дневна | - Кухня
+----S----+
|
[ Баня ]";
assert_eq!(format!("{}", room), expected);
}
#[test]
fn test_short() {
let room = Room {
name: String::from("X"),
north: String::from("N"),
south: String::from("S"),
east: String::from("E"),
west: String::from("W"),
};
let expected = "
[ N ]
|
+-N-+
W - | X | - E
+-S-+
|
[ S ]";
assert_eq!(format!("{}", room), expected);
}
}
Compiling solution v0.1.0 (/tmp/d20220120-3533338-m4ewo1/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.89s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... ok
test solution_test::test_short ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Аристотелис Папанис
  • Коректно
  • 3 успешни тест(а)
  • 0 неуспешни тест(а)
Аристотелис Папанис

use std::fmt::{self, Formatter};
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
impl fmt::Display for Room {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
let starting_length: usize = self.west.chars().count() + 3;
let west_str: String = String::from(&self.west) + " - |";
let east_str: String = "| - ".to_string() + &self.east;
let middle_length: usize = if self.name.chars().count() % 2 == 0 {
3 + self.name.chars().count()
} else {
2 + self.name.chars().count()
};
let middle_name: String = if self.name.chars().count() % 2 == 0 {
String::from(" ".to_string() + &self.name + " ")
} else {
String::from(" ".to_string() + &self.name + " ")
};
let mut upper_box: String = String::new();
let mut bott_box: String = String::new();
for _ in 0..starting_length {
upper_box += " ";
bott_box += " ";
}
upper_box += "+";
bott_box += "+";
for i in 0..middle_length {
if i == middle_length / 2 {
upper_box += "N";
bott_box += "S";
} else {
upper_box += "-";
bott_box += "-";
}
}
upper_box += "+";
bott_box += "+";
let mut str_line: String = String::new();
for _ in 0..(starting_length + middle_length / 2 + 1) {
str_line += " ";
}
str_line += "|";
let mut north_str: String = String::new();
let mut south_str: String = String::new();
for _ in 0..starting_length {
north_str += " ";
south_str += " ";
}
north_str += "[";
south_str += "[";
for _ in 0..(middle_length - self.north.chars().count()) / 2 {
north_str += " ";
}
for _ in 0..(middle_length - self.south.chars().count()) / 2 {
south_str += " ";
}
north_str += &self.north;
south_str += &self.south;
if (middle_length - self.north.chars().count()) % 2 == 1 {
north_str += " ";
}
if (middle_length - self.south.chars().count()) % 2 == 1 {
south_str += " ";
}
for _ in 0..(middle_length - self.north.chars().count()) / 2 {
north_str += " ";
}
for _ in 0..(middle_length - self.south.chars().count()) / 2 {
south_str += " ";
}
north_str += "]";
south_str += "]";
write!(
f,
"\n{}\n{}\n{}\n{}{}{}\n{}\n{}\n{}",
north_str,
str_line,
upper_box,
west_str,
middle_name,
east_str,
bott_box,
str_line,
south_str
)
}
}
#[test]
fn test_short() {
let room = Room {
name: String::from("X"),
north: String::from("N"),
south: String::from("S"),
east: String::from("E"),
west: String::from("W"),
};
let expected = "
[ N ]
|
+-N-+
W - | X | - E
+-S-+
|
[ S ]";
assert_eq!(format!("{}", room), expected);
} 
Compiling solution v0.1.0 (/tmp/d20220120-3533338-1qeljz6/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.59s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... ok
test solution_test::test_short ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Димо Чанев
  • Коректно
  • 3 успешни тест(а)
  • 0 неуспешни тест(а)
Димо Чанев

use std::fmt::{Display, Formatter, Result};
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
impl Display for Room {
#[allow(unused_must_use)]
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
let left = self.west.chars().count() + 3;
let mut middle = self.name.chars().count() + 2;
if middle % 2 == 0 {
middle += 1;
}
writeln!(f, "");
writeln!(
f,
"{}[{}{}{}{}]",
" ".repeat(left),
" ".repeat((middle - self.north.chars().count()) / 2),
self.north,
" ".repeat((middle - self.north.chars().count()) / 2),
" ".repeat(
middle
- self.north.chars().count()
- 2 * ((middle - self.north.chars().count()) / 2)
)
);
writeln!(f, "{}|", " ".repeat(left + middle / 2 + 1));
writeln!(f, "{0}+{1}N{1}+", " ".repeat(left), "-".repeat(middle / 2));
writeln!(
f,
"{} - | {}{} | - {}",
self.west,
self.name,
if self.name.chars().count() % 2 == 0 {
" "
} else {
""
},
self.east
);
writeln!(f, "{0}+{1}S{1}+", " ".repeat(left), "-".repeat(middle / 2));
writeln!(f, "{}|", " ".repeat(left + middle / 2 + 1));
write!(
f,
"{}[{}{}{}{}]",
" ".repeat(left),
" ".repeat((middle - self.south.chars().count()) / 2),
self.south,
" ".repeat((middle - self.south.chars().count()) / 2),
" ".repeat(
middle
- self.south.chars().count()
- 2 * ((middle - self.south.chars().count()) / 2)
)
)
}
}
Compiling solution v0.1.0 (/tmp/d20220120-3533338-19eqb10/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.53s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... ok
test solution_test::test_short ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Иван Стефанов
  • Некоректно
  • 2 успешни тест(а)
  • 1 неуспешни тест(а)
Иван Стефанов

use std::fmt;
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
impl fmt::Display for Room {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let (nl,wl,cl,sl) : (usize,usize,usize,usize) = (self.north.len(),self.west.len(),self.name.len(),self.south.len());
let max : usize = *[nl,cl,sl].iter().max().unwrap() + 2;
let minuses : &str = &"-".repeat((max-1)/2);
let small_offset : &str = &" ".repeat(wl+3);
let large_offset : &str = &" ".repeat(wl+4+max/2);
let north_offset : &str = &" ".repeat((max-nl)/2);
let central_offset : &str = &" ".repeat((max-cl)/2);
let south_offset : &str = &" ".repeat((max-sl)/2);
let mut output : String = String::from("\n");
let extra = if nl & 1 == 0 {" "} else {""};
output.push_str(&("".to_owned() + small_offset + "[" + north_offset + &self.north + north_offset + extra + "]\n"));
output.push_str(&("".to_owned() + large_offset + "|\n" + small_offset + "+" + minuses + "N" + minuses));
let extra = if cl & 1 == 0 {" "} else {""};
output.push_str(&("+\n".to_owned() + &self.west + " - |" + central_offset + &self.name + central_offset + extra + "| - " + &self.east + "\n"));
output.push_str(&("".to_owned() + small_offset + "+" + minuses + "S" + minuses + "+\n" + large_offset + "|\n"));
let extra = if sl & 1 == 0 {" "} else {""};
output.push_str(&("".to_owned() + small_offset + "[" + south_offset + &self.south + south_offset + extra + "]"));
write!(f, "{}",output)
}
}
Compiling solution v0.1.0 (/tmp/d20220120-3533338-1o0vh9a/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.49s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... FAILED
test solution_test::test_short ... ok

failures:

---- solution_test::test_cyrillic stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `"\n           [ Тераса  ]\n                   |\n           +------N------+\nВход - | Дневна  | - Кухня\n           +------S------+\n                   |\n           [   Баня    ]"`,
 right: `"\n       [ Тераса  ]\n            |\n       +----N----+\nВход - | Дневна  | - Кухня\n       +----S----+\n            |\n       [  Баня   ]"`', tests/solution_test.rs:45:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    solution_test::test_cyrillic

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

error: test failed, to rerun pass '--test solution_test'
Ростислав Цачев
  • Коректно
  • 3 успешни тест(а)
  • 0 неуспешни тест(а)
Ростислав Цачев

use std::fmt;
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
impl Room {
fn get_room_width(name: &String) -> usize {
let name_length = name.chars().count();
if name_length % 2 == 0 {
name_length + 1
} else {
name_length
}
}
/// Gives the number of spaces that should be printed
/// in front of the box of the `north`, `south`, `inner` rooms
fn get_distance_to_boxes(&self) -> usize {
self.west.chars().count() + 3
}
/// Gives the number of spaces that should be printed before and after the
/// North/South room names in the boxes
fn get_distance_in_outer_box(outer_room_name: &String, inner_room_name: &String) -> usize {
(Self::get_room_width(inner_room_name) - Self::get_room_width(outer_room_name)) / 2 + 1
}
fn get_distance_to_center(&self) -> usize {
self.get_distance_to_boxes() + 1 + (Self::get_room_width(&self.name) + 2) / 2
}
fn get_minus_times(&self) -> usize {
(Self::get_room_width(&self.name) + 1) / 2
}
}
impl fmt::Display for Room {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "\n");
let mut blanks_to_boxes = String::new();
for _ in 0 .. self.get_distance_to_boxes() {
blanks_to_boxes.push(' ');
}
let mut blanks_to_center = String::new();
for _ in 0 .. self.get_distance_to_center() {
blanks_to_center.push(' ');
}
let mut north_blanks_in_box = String::new();
for _ in 0 .. Self::get_distance_in_outer_box(&self.north, &self.name) {
north_blanks_in_box.push(' ');
}
let mut south_blanks_in_box = String::new();
for _ in 0 .. Self::get_distance_in_outer_box(&self.south, &self.name) {
south_blanks_in_box.push(' ');
}
let mut minuses = String::new();
for _ in 0 .. self.get_minus_times() {
minuses.push('-');
}
// North room line
let mut formatted_north_room_name = self.north.clone();
if self.north.chars().count() % 2 == 0 {
formatted_north_room_name.push(' ');
}
write!(f, "{}[{}{}{}]\n", blanks_to_boxes, north_blanks_in_box, formatted_north_room_name, north_blanks_in_box);
// Vertical bar line
write!(f, "{}|\n", blanks_to_center);
// North side box line
write!(f, "{}+{}N{}+\n", blanks_to_boxes, minuses, minuses);
let mut formatted_inner_room_name = self.name.clone();
if self.name.chars().count() % 2 == 0 {
formatted_inner_room_name.push(' ');
}
// Middle line
write!(f, "{} - | {} | - {}\n", self.west, formatted_inner_room_name, self.east);
// South side box line
write!(f, "{}+{}S{}+\n", blanks_to_boxes, minuses, minuses);
// Vertical bar line
write!(f, "{}|\n", blanks_to_center);
// South room line
let mut formatted_south_room_name = self.south.clone();
if self.south.chars().count() % 2 == 0 {
formatted_south_room_name.push(' ');
}
write!(f, "{}[{}{}{}]", blanks_to_boxes, south_blanks_in_box, formatted_south_room_name, south_blanks_in_box)
}
}
#[test]
fn test_short() {
let room = Room {
name: String::from("X"),
north: String::from("N"),
south: String::from("S"),
east: String::from("E"),
west: String::from("W"),
};
let expected = "
[ N ]
|
+-N-+
W - | X | - E
+-S-+
|
[ S ]";
assert_eq!(format!("{}", room), expected);
}
#[test]
fn test_sample() {
let room = Room {
name: String::from("Living Room"),
north: String::from("Balcony"),
south: String::from("Bathroom"),
east: String::from("Kitchen"),
west: String::from("Entrance"),
};
let expected = "
[ Balcony ]
|
+------N------+
Entrance - | Living Room | - Kitchen
+------S------+
|
[ Bathroom ]";
assert_eq!(format!("{}", room), expected);
}
#[test]
fn test_another_sample() {
let room = Room {
name: String::from("Дневна"),
north: String::from("Тераса"),
south: String::from("Баня"),
east: String::from("Кухня"),
west: String::from("Вход"),
};
let expected = "
[ Тераса ]
|
+----N----+
Вход - | Дневна | - Кухня
+----S----+
|
[ Баня ]";
assert_eq!(format!("{}", room), expected);
} 
Compiling solution v0.1.0 (/tmp/d20220120-3533338-186vkxq/solution)
warning: unused `Result` that must be used
  --> src/lib.rs:46:9
   |
46 |         write!(f, "\n");
   |         ^^^^^^^^^^^^^^^
   |
   = note: `#[warn(unused_must_use)]` on by default
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:78:9
   |
78 |         write!(f, "{}[{}{}{}]\n", blanks_to_boxes, north_blanks_in_box, formatted_north_room_name, north_blanks_in_box);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:81:9
   |
81 |         write!(f, "{}|\n", blanks_to_center);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:84:9
   |
84 |         write!(f, "{}+{}N{}+\n", blanks_to_boxes, minuses, minuses);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:92:9
   |
92 |         write!(f, "{} - | {} | - {}\n", self.west, formatted_inner_room_name, self.east);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:95:9
   |
95 |         write!(f, "{}+{}S{}+\n", blanks_to_boxes, minuses, minuses);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:98:9
   |
98 |         write!(f, "{}|\n", blanks_to_center);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: `solution` (lib) generated 7 warnings
    Finished test [unoptimized + debuginfo] target(s) in 1.69s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... ok
test solution_test::test_short ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Тодор Тодоров
  • Коректно
  • 3 успешни тест(а)
  • 0 неуспешни тест(а)
Тодор Тодоров

#![allow(non_snake_case)]
use std::{fmt, cmp::{max}};
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
impl fmt::Display for Room {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let box_len = max(self.north.chars().count(), max(self.name.chars().count(), self.south.chars().count())) + 4 +
if max(self.north.chars().count(), max(self.name.chars().count(), self.south.chars().count())) % 2 == 0 {1} else {0};
let west = self.west.clone() + " - ";
let west_len = west.chars().count();
let east = " - ".to_string() + self.east.as_str();
let dashes_n = " ".repeat(west_len) + format!("+{:-^_box_len$}+", "N", _box_len = box_len-2).as_str();
let dashes_s = " ".repeat(west_len) + format!("+{:-^_box_len$}+", "S", _box_len = box_len-2).as_str();
let north = " ".repeat(west_len) + format!("[{:^_box_len$}]", self.north, _box_len = box_len-2).as_str();
let south = " ".repeat(west_len) + format!("[{:^_box_len$}]", self.south, _box_len = box_len-2).as_str();
let center = (west.clone() + format!("|{:^_box_len$}|", self.name, _box_len = box_len-2).as_str()) + east.as_str();
let arrow = " ".repeat(west_len + (dashes_n.chars().count() - west_len)/2) + "|";
write!(f, "\n{}\n{}\n{}\n{}\n{}\n{}\n{}", north, arrow, dashes_n, center, dashes_s, arrow, south)
}
}
#[cfg(test)]
mod tests {
use crate::{Room};
#[test]
fn test_short1() {
let room = Room {
name: String::from("X"),
north: String::from("N"),
south: String::from("S"),
east: String::from("E"),
west: String::from("W"),
};
let expected = "
[ N ]
|
+-N-+
W - | X | - E
+-S-+
|
[ S ]";
assert_eq!(format!("{}", room), expected);
}
#[test]
fn test_short2() {
let room = Room {
name: String::from("Дневна"),
north: String::from("Тераса"),
south: String::from("Баня"),
east: String::from("Кухня"),
west: String::from("Вход"),
};
let expected = "
[ Тераса ]
|
+----N----+
Вход - | Дневна | - Кухня
+----S----+
|
[ Баня ]";
assert_eq!(format!("{}", room), expected);
}
#[test]
fn test_short3() {
let room = Room {
name: String::from("Living Room"),
north: String::from("Balcony"),
south: String::from("Bathroom"),
east: String::from("Kitchen"),
west: String::from("Entrance"),
};
let expected = "
[ Balcony ]
|
+------N------+
Entrance - | Living Room | - Kitchen
+------S------+
|
[ Bathroom ]";
assert_eq!(format!("{}", room), expected);
}
} 
Compiling solution v0.1.0 (/tmp/d20220120-3533338-1salln5/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.57s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... ok
test solution_test::test_short ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Волен Димитров
  • Коректно
  • 3 успешни тест(а)
  • 0 неуспешни тест(а)
Волен Димитров

use std::fmt;
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
impl fmt::Display for Room {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn format(x: &String) -> String {
if x.chars().count()%2==0 {
x.to_owned()+" "
}
else {
x.to_string()
}
}
//first line
write!(f, "\n{: >1$}\n", format!("[{: ^1$}]", format(&self.north), format(&self.name).chars().count()+2), self.west.chars().count()+3+format(&self.name).chars().count()+4);
//second line
write!(f, "{: >1$}\n", "|", self.west.chars().count()+3+((format(&self.name).chars().count()+4)/2)+1);
//third line
write!(f, "{: >1$}\n", format!("+{:-^1$}+", "N", format(&self.name).chars().count()+2), self.west.chars().count()+3+format(&self.name).chars().count()+4);
//fourth line
write!(f, "{} {} {}\n", self.west ,format!("- |{: ^1$}| -", format(&self.name), format(&self.name).chars().count()+2), self.east);
//fifth line
write!(f, "{: >1$}\n", format!("+{:-^1$}+", "S", format(&self.name).chars().count()+2), self.west.chars().count()+3+format(&self.name).chars().count()+4);
//sixth line
write!(f, "{: >1$}\n", "|", self.west.chars().count()+3+((format(&self.name).chars().count()+4)/2)+1);
//seventh line
write!(f, "{: >1$}", format!("[{: ^1$}]", format(&self.south), format(&self.name).chars().count()+2), self.west.chars().count()+3+format(&self.name).chars().count()+4);
Ok(())
}
}
Compiling solution v0.1.0 (/tmp/d20220120-3533338-1u9r5md/solution)
warning: unused `Result` that must be used
  --> src/lib.rs:23:9
   |
23 | ...   write!(f, "\n{: >1$}\n", format!("[{: ^1$}]", format(&self.north), format(&self.name).chars().count()+2), self.west.chars().count()+3+format(&self.name).chars().count()+...
   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: `#[warn(unused_must_use)]` on by default
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:26:9
   |
26 |         write!(f, "{: >1$}\n", "|", self.west.chars().count()+3+((format(&self.name).chars().count()+4)/2)+1);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:29:9
   |
29 | ...   write!(f, "{: >1$}\n", format!("+{:-^1$}+", "N", format(&self.name).chars().count()+2), self.west.chars().count()+3+format(&self.name).chars().count()+...
   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:32:9
   |
32 |         write!(f, "{} {} {}\n", self.west ,format!("- |{: ^1$}| -", format(&self.name), format(&self.name).chars().count()+2), self.east);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:35:9
   |
35 | ...   write!(f, "{: >1$}\n", format!("+{:-^1$}+", "S", format(&self.name).chars().count()+2), self.west.chars().count()+3+format(&self.name).chars().count()+...
   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:38:9
   |
38 |         write!(f, "{: >1$}\n", "|", self.west.chars().count()+3+((format(&self.name).chars().count()+4)/2)+1);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:41:9
   |
41 | ...   write!(f, "{: >1$}", format!("[{: ^1$}]", format(&self.south), format(&self.name).chars().count()+2), self.west.chars().count()+3+format(&self.name).chars().count()+...
   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: `solution` (lib) generated 7 warnings
    Finished test [unoptimized + debuginfo] target(s) in 1.65s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... ok
test solution_test::test_short ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Петър Павлов
  • Коректно
  • 3 успешни тест(а)
  • 0 неуспешни тест(а)
Петър Павлов

use std::fmt;
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
impl fmt::Display for Room {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let new_name =
if self.name.chars().count() % 2 != 0 {self.name.clone()}
else {format!("{} ", self.name)};
let new_north =
if self.north.chars().count() % 2 != 0 {self.north.clone()}
else {format!("{} ", self.north)};
let new_south =
if self.south.chars().count() % 2 != 0 {self.south.clone()}
else {format!("{} ", self.south)};
let north_space = " ".repeat((new_name.chars().count() - new_north.chars().count())/2 + 1);
let south_space = " ".repeat((new_name.chars().count() - new_south.chars().count())/2 + 1);
let dashes = "-".repeat((new_name.chars().count()+1)/2);
let mut result = format!("\n{}"," ".repeat(self.west.chars().count()+3));
result = format!("{}[{}{}{}]\n",result,north_space,new_north,north_space);
result = format!("{}{}|\n",result," ".repeat(self.west.chars().count()+(new_name.chars().count()+1)/2+4));
result = format!("{}{}+{}N{}+\n",result," ".repeat(self.west.chars().count()+3),dashes,dashes);
result = format!("{}{} - | {} | - {}\n",result,self.west,new_name,self.east);
result = format!("{}{}+{}S{}+\n",result," ".repeat(self.west.chars().count()+3),dashes,dashes);
result = format!("{}{}|\n",result," ".repeat(self.west.chars().count()+(new_name.chars().count()+1)/2+4));
result = format!("{}{}[{}{}{}]",result," ".repeat(self.west.chars().count()+3),south_space,new_south,south_space);
write!(f,"{}",result)
}
}
Compiling solution v0.1.0 (/tmp/d20220120-3533338-cz5xl6/solution)
    Finished test [unoptimized + debuginfo] target(s) in 1.50s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... ok
test solution_test::test_short ... ok

test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
Марио Лалов
  • Некоректно
  • 2 успешни тест(а)
  • 1 неуспешни тест(а)
Марио Лалов

use std::fmt;
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
#[derive(Clone, Copy)]
pub enum Direction {
North,
South,
East,
West,
}
impl Room {
fn get_ceil_floor(&self, direction: Direction) -> String {
let mut row = String::new();
let cur_len = match direction {
Direction::North => self.north.chars().count(),
Direction::South => self.south.chars().count(),
_ => 0,
};
for i in 0..self.west.chars().count() {
row.push(' ');
}
row += " [";
let buff_size = self.name.chars().count() + if self.name.chars().count() % 2 == 0 { 3 } else { 2 };
let lbuff = (buff_size - cur_len) / 2 + 1;
let rbuff = if cur_len % 2 == 0 { lbuff + 1 } else { lbuff };
for i in 1..lbuff {
row.push(' ');
}
row += match direction {
Direction::North => &self.north,
Direction::South => &self.south,
_ => "",
};
for i in 1..rbuff {
row.push(' ');
}
row += "]";
row
}
fn get_central_row(&self) -> String {
let mut row = String::new();
row += &self.west;
row += " - |";
let rbuff = 1;
let lbuff = if self.name.chars().count() % 2 == 0 { 2 } else { 1 };
for i in 0..rbuff {
row.push(' ');
}
row += &self.name;
for i in 0..lbuff {
row.push(' ');
}
row += "| - ";
row += &self.east;
row
}
fn get_box_size(&self) -> usize {
let rbuff = 1;
let lbuff = if self.name.chars().count() % 2 == 0 { 2 } else { 1 };
rbuff + lbuff + self.name.chars().count() //add 2 for pluses on both ends
}
fn get_enwraping(&self, direction: Direction) -> String {
let mut row = String::new();
let box_size = self.get_box_size();
for i in 1..self.west.chars().count() + 4 {
row.push(' ');
}
row.push('+');
let buff = (box_size + 1) / 2;
for i in 1..buff {
row.push('-');
}
match direction {
Direction::North => row.push('N'),
Direction::South => row.push('S'),
_ => row.push(' '),
};
for i in 1..buff {
row.push('-');
}
row.push('+');
row
}
fn get_empty(&self) -> String {
let mut row = String::new();
let buff = if self.name.chars().count() == 1{
self.get_box_size()/2
}else{
(self.get_box_size() + 1)/2
};
for i in 0..(buff + 4 + self.east.chars().count()) {
print!("num {}, ", i);
row.push(' ');
}
row.push('|');
row
}
}
impl fmt::Display for Room {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut rows: Vec<String> = Vec::new();
rows.push(self.get_ceil_floor(Direction::North));
rows[0] += "\n";
rows[0] = String::from("\n") + &rows[0];
rows.push(self.get_empty());
rows[1] += "\n";
rows.push(self.get_enwraping(Direction::North));
rows[2] += "\n";
rows.push(self.get_central_row());
rows[3] += "\n";
rows.push(self.get_enwraping(Direction::South));
rows[4] += "\n";
rows.push(self.get_empty());
rows[5] += "\n";
rows.push(self.get_ceil_floor(Direction::South));
let full_str = String::from(
rows[0].clone() + &rows[1] + &rows[2] + &rows[3] + &rows[4] + &rows[5] + &rows[6],
);
write!(f, "{}", full_str);
Ok(())
}
}
Compiling solution v0.1.0 (/tmp/d20220120-3533338-11ljlio/solution)
warning: unused variable: `i`
  --> src/lib.rs:28:13
   |
28 |         for i in 0..self.west.chars().count() {
   |             ^ help: if this is intentional, prefix it with an underscore: `_i`
   |
   = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `i`
  --> src/lib.rs:39:13
   |
39 |         for i in 1..lbuff {
   |             ^ help: if this is intentional, prefix it with an underscore: `_i`

warning: unused variable: `i`
  --> src/lib.rs:49:13
   |
49 |         for i in 1..rbuff {
   |             ^ help: if this is intentional, prefix it with an underscore: `_i`

warning: unused variable: `i`
  --> src/lib.rs:67:13
   |
67 |         for i in 0..rbuff {
   |             ^ help: if this is intentional, prefix it with an underscore: `_i`

warning: unused variable: `i`
  --> src/lib.rs:73:13
   |
73 |         for i in 0..lbuff {
   |             ^ help: if this is intentional, prefix it with an underscore: `_i`

warning: unused variable: `i`
  --> src/lib.rs:94:13
   |
94 |         for i in 1..self.west.chars().count() + 4 {
   |             ^ help: if this is intentional, prefix it with an underscore: `_i`

warning: unused variable: `i`
   --> src/lib.rs:102:13
    |
102 |         for i in 1..buff {
    |             ^ help: if this is intentional, prefix it with an underscore: `_i`

warning: unused variable: `i`
   --> src/lib.rs:112:13
    |
112 |         for i in 1..buff {
    |             ^ help: if this is intentional, prefix it with an underscore: `_i`

warning: unused `Result` that must be used
   --> src/lib.rs:163:9
    |
163 |         write!(f, "{}", full_str);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: `#[warn(unused_must_use)]` on by default
    = note: this `Result` may be an `Err` variant, which should be handled
    = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: `solution` (lib) generated 9 warnings
    Finished test [unoptimized + debuginfo] target(s) in 2.29s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... FAILED
test solution_test::test_short ... ok

failures:

---- solution_test::test_cyrillic stdout ----
num 0, num 1, num 2, num 3, num 4, num 5, num 6, num 7, num 8, num 9, num 10, num 11, num 12, num 13, num 0, num 1, num 2, num 3, num 4, num 5, num 6, num 7, num 8, num 9, num 10, num 11, num 12, num 13, thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `"\n       [ Тераса  ]\n              |\n       +----N----+\nВход - | Дневна  | - Кухня\n       +----S----+\n              |\n       [  Баня   ]"`,
 right: `"\n       [ Тераса  ]\n            |\n       +----N----+\nВход - | Дневна  | - Кухня\n       +----S----+\n            |\n       [  Баня   ]"`', tests/solution_test.rs:45:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    solution_test::test_cyrillic

test result: FAILED. 2 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 неуспешни тест(а)
Пламен Берберов

use std::fmt::{Display, Formatter, Result};
use std::cmp::max;
pub struct Room {
pub name: String,
pub north: String,
pub south: String,
pub east: String,
pub west: String,
}
fn padString (str: &mut String, pad: usize) {
let mut k = 0;
while k < pad {
str.insert(0, ' ');
k+=1;
}
}
fn separatorLine (length: usize, center: char) -> String {
let mut k = 0;
let mut result = String::from("+");
while k < (length-1)/2 {
result.push( '-');
k+=1;
}
result.push(center);
k=0;
while k < (length-1)/2 {
result.push( '-');
k+=1;
}
result.push('+');
result
}
impl Display for Room {
fn fmt(&self, f: &mut Formatter<'_>) -> Result {
let left_padding = self.west.len() + 3;
let content_length = max(max(self.north.len(), self.name.len()), self.south.len())
+ 2 * ((self.name.len() + 1) % 2);
let center_padding = left_padding + content_length/2 + 2;
write!(f, "\n");
let mut north = self.north.clone();
let north_content_pad_left = (content_length - north.len()) / 2;
let north_content_pad_right = (content_length - north.len()) / 2 + (content_length - north.len()) % 2;
padString(&mut north, north_content_pad_left);
let mut north_content_tail = String::from(" ]");
padString(&mut north_content_tail, north_content_pad_right);
let mut north_row = String::from("[ ") + north.as_str() + north_content_tail.as_str();
padString(&mut north_row, left_padding);
write!(f, "{}\n", north_row);
let mut pipe_row = String::from("|");
padString(&mut pipe_row, center_padding);
write!(f, "{}\n", pipe_row);
let mut separator_row = separatorLine(content_length + 2 - ((self.name.len() + 1) % 2), 'N');
padString(&mut separator_row, left_padding);
write!(f, "{}\n", separator_row);
match self.name.len() % 2 == 0 {
true => write!(f, "{} - | {} | - {}\n", self.west, self.name, self.east),
false => write!(f, "{} - | {} | - {}\n", self.west, self.name, self.east)
};
separator_row = separatorLine(content_length + 2 - ((self.name.len() + 1) % 2), 'S');
padString(&mut separator_row, left_padding);
write!(f, "{}\n", separator_row);
write!(f, "{}\n", pipe_row);
let mut south = self.south.clone();
let south_content_pad_left = (content_length - south.len()) / 2;
let south_content_pad_right = (content_length - south.len()) / 2 + (content_length - south.len()) % 2;
padString(&mut south, south_content_pad_left);
let mut south_content_tail = String::from(" ]");
padString(&mut south_content_tail, south_content_pad_right);
let mut south_row = String::from("[ ") + south.as_str() + south_content_tail.as_str();
padString(&mut south_row, left_padding);
write!(f, "{}", south_row);
Ok(())
}
}
Compiling solution v0.1.0 (/tmp/d20220120-3533338-ddsxdc/solution)
warning: function `padString` should have a snake case name
  --> src/lib.rs:12:4
   |
12 | fn padString (str: &mut String, pad: usize) {
   |    ^^^^^^^^^ help: convert the identifier to snake case: `pad_string`
   |
   = note: `#[warn(non_snake_case)]` on by default

warning: function `separatorLine` should have a snake case name
  --> src/lib.rs:20:4
   |
20 | fn separatorLine (length: usize, center: char) -> String {
   |    ^^^^^^^^^^^^^ help: convert the identifier to snake case: `separator_line`

warning: unused `Result` that must be used
  --> src/lib.rs:44:9
   |
44 |         write!(f, "\n");
   |         ^^^^^^^^^^^^^^^
   |
   = note: `#[warn(unused_must_use)]` on by default
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:54:9
   |
54 |         write!(f, "{}\n", north_row);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:58:9
   |
58 |         write!(f, "{}\n", pipe_row);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:62:9
   |
62 |         write!(f, "{}\n", separator_row);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:64:9
   |
64 | /         match self.name.len() % 2 == 0 {
65 | |             true => write!(f, "{} - | {}  | - {}\n", self.west, self.name, self.east),
66 | |             false => write!(f, "{} - | {} | - {}\n", self.west, self.name, self.east)
67 | |         };
   | |__________^
   |
   = note: this `Result` may be an `Err` variant, which should be handled

warning: unused `Result` that must be used
  --> src/lib.rs:71:9
   |
71 |         write!(f, "{}\n", separator_row);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:73:9
   |
73 |         write!(f, "{}\n", pipe_row);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: unused `Result` that must be used
  --> src/lib.rs:83:9
   |
83 |         write!(f, "{}", south_row);
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: this warning originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)

warning: `solution` (lib) generated 10 warnings
    Finished test [unoptimized + debuginfo] target(s) in 1.62s
     Running tests/solution_test.rs (target/debug/deps/solution_test-2e292b23ac75572c)

running 3 tests
test solution_test::test_basic ... ok
test solution_test::test_cyrillic ... FAILED
test solution_test::test_short ... ok

failures:

---- solution_test::test_cyrillic stdout ----
thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `"\n           [  Тераса  ]\n                    |\n           +-------N-------+\nВход - | Дневна  | - Кухня\n           +-------S-------+\n                    |\n           [    Баня    ]"`,
 right: `"\n       [ Тераса  ]\n            |\n       +----N----+\nВход - | Дневна  | - Кухня\n       +----S----+\n            |\n       [  Баня   ]"`', tests/solution_test.rs:45:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    solution_test::test_cyrillic

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

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