Решение на Форматиране на импорти от Енислав Енчев
Резултати
- 18 точки от тестове
- 0 бонус точки
- 18 точки общо
- 18 успешни тест(а)
- 2 неуспешни тест(а)
Код
pub struct Import<'a>(pub &'a [&'a str]);
#[derive(PartialEq)]
#[derive(Clone)]
pub enum Order {
Original,
Sorted,
}
pub fn format_flat(imports: &[Import], order: Order) -> Vec<String> {
let mut imps : Vec<String> = Vec::new();
for import in imports {
let concat = import.0.join("::");
if !imps.contains(&concat){
imps.push(concat)
}
}
if order == Order::Sorted {
imps.sort();
}
imps
}
#[derive(Debug)]
pub struct Node{
standalone : bool,
name : String,
level : u32,
subelements : Vec<Node>,
}
impl Node {
pub fn new(nm: &str, lvl: u32) -> Node {
Node {
standalone: false,
name: nm.to_string(),
level: lvl,
subelements: Vec::new(),
}
}
}
pub fn add_crate(node: &mut Node, import: &[&str], level: u32) -> (){
if !import.is_empty(){
//working let sub : String = import[0].clone().to_string();
let sub : String = import[0].to_string();
let len : usize = node.subelements.len();
let mut i : usize = 0;
while i < len{
if node.subelements[i].name == sub{
add_crate(&mut node.subelements[i], &import[1..], level + 1);
break;
}
i += 1;
}
if i == len{
//working let mut new_node = Node::new(&sub, level + 1);
let new_node = Node::new(&sub, level + 1);
&mut node.subelements.push(new_node);
add_crate(&mut node.subelements[i], &import[1..], level + 1);
}
}else{
*&mut node.standalone = true;
}
()
}
pub fn print_crate(node: &mut Node, order: Order) -> String{
let mut current_string : String = String::from("");
for _i in 0..node.level{
current_string.push_str(" ");
}
//maybe node.name.clone()
current_string.push_str(&node.name);
if !node.subelements.is_empty(){
current_string.push_str("::{\n");
if node.standalone{
for _i in 0..node.level{
current_string.push_str(" ");
}
current_string.push_str("self,\n");
}
if order == Order::Sorted {
node.subelements.sort_by(|x, y| x.name.cmp(&y.name));
}
for sub in &mut node.subelements{
current_string.push_str(&print_crate(sub, order.clone()));
}
for _i in 0..node.level{
current_string.push_str(" ");
}
current_string.push_str("},\n");
}else{
current_string.push_str(",\n");
}
current_string
}
pub fn format_nested(imports: &[Import], order: Order) -> Vec<String> {
let mut crates : Vec<Node> = Vec::new();
for import in imports{
if !crates.iter().any(|root| root.name == import.0[0]){
//working let temp = import.0[0].clone();
let temp = import.0[0];
let new_root = Node::new(temp, 0);
crates.push(new_root);
}
}
let len : usize = crates.len();
let mut i: usize = 0;
for import in imports{
i = 0;
while i < len{
if import.0[0] == crates[i].name{
add_crate(&mut crates[i], &import.0[1..], 0);
}
i += 1;
}
}
if order == Order::Sorted{
crates.sort_by(|x, y| x.name.cmp(&y.name));
}
let mut answers : Vec<String> = Vec::new();
for crt in &mut crates{
answers.push(print_crate(crt, order.clone()));
}
for x in &mut answers{
x.pop();
x.pop();
x.push_str("\n");
}
answers
}
#[test]
fn main(){
//let imports = &[Import(&["gec", "it", "ralph"]), Import(&["std", "string", "Btring"]),Import(&["std", "string", "Btring", "hui"]), Import(&["std", "string", "String"]), Import(&["std", "string", "Atring"]),Import(&["std", "string", "Btring", "hui", "madafa"])];
//let imports = &[Import(&["gec", "it", "ralph"]),Import(&["incredible", "work", "here"]),Import(&["std", "string", "Btring", "hui"]), Import(&["incredible", "job", "here"]),Import(&["gec", "it", "ralph"]), Import(&["std", "string", "String"]), Import(&["std", "string", "Atring"]),Import(&["std", "string", "Btring", "hui", "madafa"]), Import(&["incredible", "work", "as"])];
// format_flat(imports, Order::Sorted);
// for x in format_nested(imports, Order::Sorted){
// println!("{}", x);
// }
//println!("{:?}", format_nested(imports, Order::Original));
// for x in format_flat(imports, Order::Sorted){
// println!("{}", x);
// }
let imports = &[
Import(&["my_crate", "a"]),
Import(&["my_crate", "b", "B1"]),
Import(&["my_crate", "b", "B2"]),
Import(&["my_crate", "c"]),
];
assert_eq!(
format_flat(imports, Order::Sorted),
&[
"my_crate::a",
"my_crate::b::B1",
"my_crate::b::B2",
"my_crate::c",
]
);
assert_eq!(
format_nested(imports, Order::Sorted),
&[
concat!(
"my_crate::{\n",
" a,\n",
" b::{\n",
" B1,\n",
" B2,\n",
" },\n",
" c,\n",
"}\n",
)
]
);
}
Лог от изпълнението
Compiling solution v0.1.0 (/tmp/d20241203-1739405-196b493/solution)
warning: value assigned to `i` is never read
--> src/lib.rs:110:13
|
110 | let mut i: usize = 0;
| ^
|
= help: maybe it is overwritten before being read?
= note: `#[warn(unused_assignments)]` on by default
warning: unused borrow that must be used
--> src/lib.rs:59:13
|
59 | &mut node.subelements.push(new_node);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the borrow produces a value
|
= note: `#[warn(unused_must_use)]` on by default
help: use `let _ = ...` to ignore the resulting value
|
59 | let _ = &mut node.subelements.push(new_node);
| +++++++
warning: `solution` (lib) generated 2 warnings
Finished test [unoptimized + debuginfo] target(s) in 1.72s
Running tests/solution_test.rs (target/debug/deps/solution_test-1428e1090729d165)
running 20 tests
test solution_test::test_flat_empty ... ok
test solution_test::test_flat_multi_crate ... ok
test solution_test::test_flat_original ... ok
test solution_test::test_flat_original_duplicates ... ok
test solution_test::test_flat_sorted ... ok
test solution_test::test_flat_sorted_duplicates ... ok
test solution_test::test_nested_basic ... ok
test solution_test::test_nested_deep ... ok
test solution_test::test_nested_empty ... ok
test solution_test::test_nested_only_crate ... ok
test solution_test::test_nested_original ... ok
test solution_test::test_nested_original_2 ... ok
test solution_test::test_nested_original_duplicates ... ok
test solution_test::test_nested_original_multi_crate ... ok
test solution_test::test_nested_original_self ... FAILED
test solution_test::test_nested_sorted ... ok
test solution_test::test_nested_sorted_2 ... ok
test solution_test::test_nested_sorted_duplicates ... ok
test solution_test::test_nested_sorted_multi_crate ... ok
test solution_test::test_nested_sorted_self ... FAILED
failures:
---- solution_test::test_nested_original_self stdout ----
thread 'solution_test::test_nested_original_self' panicked at 'assertion failed: `(left == right)`
left: `["my_crate::{\n c,\n b::{\n self,\n B2,\n B1,\n },\n a,\n}\n"]`,
right: `["my_crate::{\n c,\n b::{\n self,\n B2,\n B1,\n },\n a,\n}\n"]`', tests/solution_test.rs:334:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- solution_test::test_nested_sorted_self stdout ----
thread 'solution_test::test_nested_sorted_self' panicked at 'assertion failed: `(left == right)`
left: `["my_crate::{\n a,\n b::{\n self,\n B1,\n B2,\n },\n c,\n}\n"]`,
right: `["my_crate::{\n a,\n b::{\n self,\n B1,\n B2,\n },\n c,\n}\n"]`', tests/solution_test.rs:360:5
failures:
solution_test::test_nested_original_self
solution_test::test_nested_sorted_self
test result: FAILED. 18 passed; 2 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass `--test solution_test`