Решение на Форматиране на импорти от Максим Георгиев
Към профила на Максим Георгиев
Резултати
- 10 точки от тестове
- 0 бонус точки
- 10 точки общо
- 10 успешни тест(а)
- 10 неуспешни тест(а)
Код
pub struct Import<'a>(pub &'a [&'a str]);
pub enum Order {
Original,
Sorted,
}
fn concatinate_imports(imports: &[Import]) -> Vec<String> {
let mut res: Vec<String> = Vec::new();
for import in imports {
res.push(import.0.join("::"));
}
return res;
}
fn remove_dublicates(vec: &mut Vec<String>) {
for i in 0..&vec.len() - 0 {
for j in i + 1..vec.len() - 1 {
if vec[i] == vec[j] {
vec.remove(j);
}
}
}
}
fn add_self(vec: &mut Vec<String>) {
let mut is_prefix = true;
let mut i = 0;
while i < &vec.len() - 1 {
let a = &mut vec[i].chars().into_iter();
let b = &mut vec[i + 1].chars().into_iter();
let mut c = a.next();
let mut d: Option<char>;
while c != Option::None {
d = b.next();
if c != d {
is_prefix = false;
break;
}
c = a.next();
}
if is_prefix {
let mut new = String::new();
new.push_str(&vec[i].to_string());
new.push_str("::self");
let new_vec: Vec<String> = vec.split_off(i);
vec.push(new);
for news in new_vec {
vec.push(news);
}
i += 1;
}
is_prefix = true;
i += 1;
}
}
fn sort_lexical(vec: &mut Vec<String>) -> Vec<String> {
for i in 0..vec.len() {
for j in i + 1..vec.len() {
if vec[j].chars().lt(vec[i].chars()) {
vec.swap(i, j);
}
}
}
return vec.to_vec();
}
pub fn format_flat(imports: &[Import], order: Order) -> Vec<String> {
if imports.len() == 0 {
return Vec::new();
}
let mut res = concatinate_imports(imports);
remove_dublicates(&mut res);
match order{
Order::Original => return res,
Order::Sorted => return sort_lexical(&mut res)
};
}
struct Tree {
root: Node
}
impl Tree {
fn new(node: Node) -> Self {
Tree {
root : node
}
}
}
struct Node {
_value: String,
children: Vec<Node>
}
impl Node {
fn new(name: String) -> Self {
Node {
_value : name,
children : Vec::new()
}
}
// fn add_child(mut self, node: Node) {
// self.children.push(node);
// }
fn add_children(&mut self, vec:Vec<String>) {
for str in vec {
self.children.push(Node::new(str));
}
}
}
fn init_tree(parent: &mut Node, vec: &mut Vec<String>) {
let mut firsts: Vec<String> = Vec::new();
let mut nexts: Vec<Vec<String>> = Vec::new();
if &vec.len() - 0 >= 1 {
for _i in 0..&vec.len() - 0 {
let a: Vec<String> = Vec::new();
nexts.push(a);
}
}
else { return; }
let mut i = 0;
let mut _j = 0;
for import in vec {
if import.contains("::") {
let a = import.split_once("::").unwrap();
if !firsts.contains(&a.0.to_string()) {
firsts.push(a.0.to_string());
nexts[i].push(a.1.to_string());
i += 1;
}
else {
_j += 1;
let index = firsts.iter().position(|x| x == &a.0.to_string()).unwrap();
nexts[index].push(a.1.to_string());
}
}
else {
firsts.push(import.to_string());
i += 1;
}
}
for next_i in 0..nexts.len() - 0 {
sort_lexical(&mut nexts[next_i]);
}
firsts.dedup();
parent.add_children(firsts);
for i in 0..&parent.children.len() - 0 {
init_tree(&mut parent.children[i], &mut nexts[i]);
}
}
fn tree_display(parent: Node, res: &mut Vec<String>, mut num_of_indent:i32) -> Vec<String> {
let num = parent.children.len();
let parent_name = &parent._value;
if parent_name.to_string() != "".to_string() {
num_of_indent += 1;
for _i in 0..num_of_indent - 1 {
res.push("\x20\x20\x20\x20".to_string());
}
res.push(parent_name.to_string());
if num > 0 { res.push("::{\n".to_string()); }
else { res.push(",\n".to_string()); }
}
for child in parent.children {
tree_display(child, res, num_of_indent);
}
if parent_name.to_string() != "".to_string() {
if num > 0 {
for _i in 0..num_of_indent - 1 {
res.push("\x20\x20\x20\x20".to_string());
}
res.push("},\n".to_string());
}
}
return res.to_vec();
}
fn nest(vec: &mut Vec<String>, order: Order) -> Vec<String> {
let mut tree: Tree = Tree::new(Node::new(String::new()));
add_self(vec);
match order {
Order::Original => vec,
Order::Sorted => &sort_lexical(vec)
};
init_tree(&mut tree.root, &mut vec.to_vec());
let mut res: Vec<String> = Vec::new();
tree_display(tree.root, &mut res, 0);
let mut last= res.last().unwrap().to_string();
last.pop();
last.pop();
res.remove(res.len() - 1);
res.push(last);
let mut last_enter: Vec<String> = Vec::new();
last_enter.push("\n".to_string());
res.append(&mut last_enter);
let res_string: String = res.join("");
let mut final_res: Vec<String> = Vec::new();
final_res.push(res_string);
final_res
}
pub fn format_nested(imports: &[Import], order: Order) -> Vec<String> {
if imports.len() == 0 {
return Vec::new();
}
let mut res = concatinate_imports(imports);
remove_dublicates(&mut res);
match order {
Order::Original => return nest(&mut res, order),
Order::Sorted => return nest(&mut sort_lexical(&mut res), order)
};
}
#[test]
fn test_basic() {
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-qxktmc/solution)
Finished test [unoptimized + debuginfo] target(s) in 1.32s
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 ... FAILED
test solution_test::test_flat_sorted ... ok
test solution_test::test_flat_sorted_duplicates ... FAILED
test solution_test::test_nested_basic ... ok
test solution_test::test_nested_empty ... ok
test solution_test::test_nested_only_crate ... ok
test solution_test::test_nested_deep ... ok
test solution_test::test_nested_original ... FAILED
test solution_test::test_nested_original_2 ... FAILED
test solution_test::test_nested_original_duplicates ... FAILED
test solution_test::test_nested_original_multi_crate ... FAILED
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 ... FAILED
test solution_test::test_nested_sorted_multi_crate ... FAILED
test solution_test::test_nested_sorted_self ... FAILED
failures:
---- solution_test::test_flat_original_duplicates stdout ----
thread 'solution_test::test_flat_original_duplicates' panicked at 'assertion failed: `(left == right)`
left: `["std::string::String", "std::iter::once", "std::iter", "std::iter::repeat", "std::string::String"]`,
right: `["std::string::String", "std::iter::once", "std::iter", "std::iter::repeat"]`', tests/solution_test.rs:44:5
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
---- solution_test::test_flat_sorted_duplicates stdout ----
thread 'solution_test::test_flat_sorted_duplicates' panicked at 'assertion failed: `(left == right)`
left: `["std::iter", "std::iter::once", "std::iter::repeat", "std::string::String", "std::string::String"]`,
right: `["std::iter", "std::iter::once", "std::iter::repeat", "std::string::String"]`', tests/solution_test.rs:88:5
---- solution_test::test_nested_original stdout ----
thread 'solution_test::test_nested_original' panicked at 'assertion failed: `(left == right)`
left: `["my_crate::{\n a,\n b::{\n B1,\n B2,\n },\n c,\n}\n"]`,
right: `["my_crate::{\n c,\n b::{\n B2,\n B1,\n },\n a,\n}\n"]`', tests/solution_test.rs:173:5
---- solution_test::test_nested_original_2 stdout ----
thread 'solution_test::test_nested_original_2' panicked at 'assertion failed: `(left == right)`
left: `["my_crate::{\n a::{\n A1,\n inner::{\n I1,\n },\n },\n b::{\n B1,\n B2,\n },\n c,\n}\n"]`,
right: `["my_crate::{\n c,\n b::{\n B2,\n B1,\n },\n a::{\n inner::{\n I1,\n },\n A1,\n },\n}\n"]`', tests/solution_test.rs:198:5
---- solution_test::test_nested_original_duplicates stdout ----
thread 'solution_test::test_nested_original_duplicates' panicked at 'assertion failed: `(left == right)`
left: `["my_crate::{\n a,\n b::{\n B1,\n B2,\n },\n c,\n}\n"]`,
right: `["my_crate::{\n c,\n b::{\n B2,\n B1,\n },\n a,\n}\n"]`', tests/solution_test.rs:283:5
---- solution_test::test_nested_original_multi_crate stdout ----
thread 'solution_test::test_nested_original_multi_crate' panicked at 'assertion failed: `(left == right)`
left: `["crate::{\n a,\n b,\n},\nstd::{\n string::{\n String,\n },\n}\n"]`,
right: `["crate::{\n b,\n a,\n}\n", "std::{\n string::{\n String,\n },\n}\n"]`', tests/solution_test.rs:385:5
---- solution_test::test_nested_original_self stdout ----
thread 'solution_test::test_nested_original_self' panicked at 'assertion failed: `(left == right)`
left: `["my_crate::{\n a,\n b::{\n B1,\n B2,\n },\n c,\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
---- solution_test::test_nested_sorted_duplicates stdout ----
thread 'solution_test::test_nested_sorted_duplicates' panicked at 'assertion failed: `(left == right)`
left: `["my_crate::{\n a,\n b::{\n B1,\n B2,\n },\n c::{\n self,\n },\n}\n"]`,
right: `["my_crate::{\n a,\n b::{\n B1,\n B2,\n },\n c,\n}\n"]`', tests/solution_test.rs:309:5
---- solution_test::test_nested_sorted_multi_crate stdout ----
thread 'solution_test::test_nested_sorted_multi_crate' panicked at 'assertion failed: `(left == right)`
left: `["crate::{\n a,\n b,\n},\nstd::{\n string::{\n String,\n },\n}\n"]`,
right: `["crate::{\n a,\n b,\n}\n", "std::{\n string::{\n String,\n },\n}\n"]`', tests/solution_test.rs:414:5
---- 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 B1,\n B2,\n self,\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_flat_original_duplicates
solution_test::test_flat_sorted_duplicates
solution_test::test_nested_original
solution_test::test_nested_original_2
solution_test::test_nested_original_duplicates
solution_test::test_nested_original_multi_crate
solution_test::test_nested_original_self
solution_test::test_nested_sorted_duplicates
solution_test::test_nested_sorted_multi_crate
solution_test::test_nested_sorted_self
test result: FAILED. 10 passed; 10 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass `--test solution_test`