Skip to content

Commit c76c1d6

Browse files
StarryCode-LangStarryCode-Lang
committed
04121710
1 parent 0a248c6 commit c76c1d6

File tree

2 files changed

+163
-130
lines changed

2 files changed

+163
-130
lines changed

‎exercises/algorithm/algorithm10.rs

Lines changed: 29 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,7 @@
11
/*
2-
graph
3-
This problem requires you to implement a basic graph functio
2+
graph
3+
This problem requires you to implement a basic graph functio
44
*/
5-
// I AM NOT DONE
65

76
use std::collections::{HashMap, HashSet};
87
use std::fmt;
@@ -28,21 +27,39 @@ impl Graph for UndirectedGraph {
2827
fn adjacency_table(&self) -> &HashMap<String, Vec<(String, i32)>> {
2928
&self.adjacency_table
3029
}
30+
31+
fn add_node(&mut self, node: &str) -> bool {
32+
if self.contains(node) {
33+
false
34+
} else {
35+
self.adjacency_table.insert(node.to_string(), Vec::new());
36+
true
37+
}
38+
}
3139
fn add_edge(&mut self, edge: (&str, &str, i32)) {
32-
//TODO
40+
let (src, dest, weight) = edge;
41+
if !self.contains(src) {
42+
self.add_node(src);
43+
}
44+
if !self.contains(dest) {
45+
self.add_node(dest);
46+
}
47+
self.adjacency_table
48+
.get_mut(src)
49+
.unwrap()
50+
.push((dest.to_string(), weight));
51+
self.adjacency_table
52+
.get_mut(dest)
53+
.unwrap()
54+
.push((src.to_string(), weight));
3355
}
3456
}
3557
pub trait Graph {
3658
fn new() -> Self;
3759
fn adjacency_table_mutable(&mut self) -> &mut HashMap<String, Vec<(String, i32)>>;
3860
fn adjacency_table(&self) -> &HashMap<String, Vec<(String, i32)>>;
39-
fn add_node(&mut self, node: &str) -> bool {
40-
//TODO
41-
true
42-
}
43-
fn add_edge(&mut self, edge: (&str, &str, i32)) {
44-
//TODO
45-
}
61+
fn add_node(&mut self, node: &str) -> bool;
62+
fn add_edge(&mut self, edge: (&str, &str, i32));
4663
fn contains(&self, node: &str) -> bool {
4764
self.adjacency_table().get(node).is_some()
4865
}
@@ -81,4 +98,4 @@ mod test_undirected_graph {
8198
assert_eq!(graph.edges().contains(edge), true);
8299
}
83100
}
84-
}
101+
}

‎exercises/algorithm/algorithm7.rs

Lines changed: 134 additions & 118 deletions
Original file line numberDiff line numberDiff line change
@@ -1,142 +1,158 @@
11
/*
2-
stack
3-
This question requires you to use a stack to achieve a bracket match
2+
stack
3+
This question requires you to use a stack to achieve a bracket match
44
*/
55

6-
// I AM NOT DONE
76
#[derive(Debug)]
87
struct Stack<T> {
9-
size: usize,
10-
data: Vec<T>,
8+
size: usize,
9+
data: Vec<T>,
1110
}
1211
impl<T> Stack<T> {
13-
fn new() -> Self {
14-
Self {
15-
size: 0,
16-
data: Vec::new(),
17-
}
18-
}
19-
fn is_empty(&self) -> bool {
20-
0 == self.size
21-
}
22-
fn len(&self) -> usize {
23-
self.size
24-
}
25-
fn clear(&mut self) {
26-
self.size = 0;
27-
self.data.clear();
28-
}
29-
fn push(&mut self, val: T) {
30-
self.data.push(val);
31-
self.size += 1;
32-
}
33-
fn pop(&mut self) -> Option<T> {
34-
// TODO
35-
None
36-
}
37-
fn peek(&self) -> Option<&T> {
38-
if 0 == self.size {
39-
return None;
40-
}
41-
self.data.get(self.size - 1)
42-
}
43-
fn peek_mut(&mut self) -> Option<&mut T> {
44-
if 0 == self.size {
45-
return None;
46-
}
47-
self.data.get_mut(self.size - 1)
48-
}
49-
fn into_iter(self) -> IntoIter<T> {
50-
IntoIter(self)
51-
}
52-
fn iter(&self) -> Iter<T> {
53-
let mut iterator = Iter {
54-
stack: Vec::new()
55-
};
56-
for item in self.data.iter() {
57-
iterator.stack.push(item);
58-
}
59-
iterator
60-
}
61-
fn iter_mut(&mut self) -> IterMut<T> {
62-
let mut iterator = IterMut {
63-
stack: Vec::new()
64-
};
65-
for item in self.data.iter_mut() {
66-
iterator.stack.push(item);
67-
}
68-
iterator
69-
}
12+
fn new() -> Self {
13+
Self {
14+
size: 0,
15+
data: Vec::new(),
16+
}
17+
}
18+
fn is_empty(&self) -> bool {
19+
0 == self.size
20+
}
21+
fn len(&self) -> usize {
22+
self.size
23+
}
24+
fn clear(&mut self) {
25+
self.size = 0;
26+
self.data.clear();
27+
}
28+
fn push(&mut self, val: T) {
29+
self.data.push(val);
30+
self.size += 1;
31+
}
32+
fn pop(&mut self) -> Option<T> {
33+
if self.is_empty() {
34+
None
35+
} else {
36+
self.size -= 1;
37+
self.data.pop()
38+
}
39+
}
40+
fn peek(&self) -> Option<&T> {
41+
if 0 == self.size {
42+
return None;
43+
}
44+
self.data.get(self.size - 1)
45+
}
46+
fn peek_mut(&mut self) -> Option<&mut T> {
47+
if 0 == self.size {
48+
return None;
49+
}
50+
self.data.get_mut(self.size - 1)
51+
}
52+
fn into_iter(self) -> IntoIter<T> {
53+
IntoIter(self)
54+
}
55+
fn iter(&self) -> Iter<T> {
56+
let mut iterator = Iter { stack: Vec::new() };
57+
for item in self.data.iter() {
58+
iterator.stack.push(item);
59+
}
60+
iterator
61+
}
62+
fn iter_mut(&mut self) -> IterMut<T> {
63+
let mut iterator = IterMut { stack: Vec::new() };
64+
for item in self.data.iter_mut() {
65+
iterator.stack.push(item);
66+
}
67+
iterator
68+
}
7069
}
7170
struct IntoIter<T>(Stack<T>);
7271
impl<T: Clone> Iterator for IntoIter<T> {
73-
type Item = T;
74-
fn next(&mut self) -> Option<Self::Item> {
75-
if !self.0.is_empty() {
76-
self.0.size -= 1;self.0.data.pop()
77-
}
78-
else {
79-
None
80-
}
81-
}
72+
type Item = T;
73+
fn next(&mut self) -> Option<Self::Item> {
74+
if !self.0.is_empty() {
75+
self.0.size -= 1;
76+
self.0.data.pop()
77+
} else {
78+
None
79+
}
80+
}
8281
}
8382
struct Iter<'a, T: 'a> {
84-
stack: Vec<&'a T>,
83+
stack: Vec<&'a T>,
8584
}
8685
impl<'a, T> Iterator for Iter<'a, T> {
87-
type Item = &'a T;
88-
fn next(&mut self) -> Option<Self::Item> {
89-
self.stack.pop()
90-
}
86+
type Item = &'a T;
87+
fn next(&mut self) -> Option<Self::Item> {
88+
self.stack.pop()
89+
}
9190
}
9291
struct IterMut<'a, T: 'a> {
93-
stack: Vec<&'a mut T>,
92+
stack: Vec<&'a mut T>,
9493
}
9594
impl<'a, T> Iterator for IterMut<'a, T> {
96-
type Item = &'a mut T;
97-
fn next(&mut self) -> Option<Self::Item> {
98-
self.stack.pop()
99-
}
95+
type Item = &'a mut T;
96+
fn next(&mut self) -> Option<Self::Item> {
97+
self.stack.pop()
98+
}
10099
}
101100

102-
fn bracket_match(bracket: &str) -> bool
103-
{
104-
//TODO
105-
true
101+
fn bracket_match(bracket: &str) -> bool {
102+
let mut stack = Stack::new();
103+
let matching_brackets = |c: char| match c {
104+
')' => '(',
105+
']' => '[',
106+
'}' => '{',
107+
_ => return c,
108+
};
109+
for c in bracket.chars() {
110+
match c {
111+
'(' | '[' | '{' => stack.push(c),
112+
')' | ']' | '}' => {
113+
if stack.is_empty() || *stack.peek().unwrap() != matching_brackets(c) {
114+
return false;
115+
}
116+
stack.pop();
117+
}
118+
_ => {}
119+
}
120+
}
121+
stack.is_empty()
106122
}
107123

108124
#[cfg(test)]
109125
mod tests {
110-
use super::*;
111-
112-
#[test]
113-
fn bracket_matching_1(){
114-
let s = "(2+3){func}[abc]";
115-
assert_eq!(bracket_match(s),true);
116-
}
117-
#[test]
118-
fn bracket_matching_2(){
119-
let s = "(2+3)*(3-1";
120-
assert_eq!(bracket_match(s),false);
121-
}
122-
#[test]
123-
fn bracket_matching_3(){
124-
let s = "{{([])}}";
125-
assert_eq!(bracket_match(s),true);
126-
}
127-
#[test]
128-
fn bracket_matching_4(){
129-
let s = "{{(}[)]}";
130-
assert_eq!(bracket_match(s),false);
131-
}
132-
#[test]
133-
fn bracket_matching_5(){
134-
let s = "[[[]]]]]]]]]";
135-
assert_eq!(bracket_match(s),false);
136-
}
137-
#[test]
138-
fn bracket_matching_6(){
139-
let s = "";
140-
assert_eq!(bracket_match(s),true);
141-
}
142-
}
126+
use super::*;
127+
128+
#[test]
129+
fn bracket_matching_1() {
130+
let s = "(2+3){func}[abc]";
131+
assert_eq!(bracket_match(s), true);
132+
}
133+
#[test]
134+
fn bracket_matching_2() {
135+
let s = "(2+3)*(3-1";
136+
assert_eq!(bracket_match(s), false);
137+
}
138+
#[test]
139+
fn bracket_matching_3() {
140+
let s = "{{([])}}";
141+
assert_eq!(bracket_match(s), true);
142+
}
143+
#[test]
144+
fn bracket_matching_4() {
145+
let s = "{{(}[)]}";
146+
assert_eq!(bracket_match(s), false);
147+
}
148+
#[test]
149+
fn bracket_matching_5() {
150+
let s = "[[[]]]]]]]]]";
151+
assert_eq!(bracket_match(s), false);
152+
}
153+
#[test]
154+
fn bracket_matching_6() {
155+
let s = "";
156+
assert_eq!(bracket_match(s), true);
157+
}
158+
}

0 commit comments

Comments
 (0)