169 lines
3.6 KiB
Markdown
169 lines
3.6 KiB
Markdown
1.
|
|
|
|
```rust
|
|
// FILL in the blanks and FIX the erros
|
|
use std::collections::HashMap;
|
|
fn main() {
|
|
let mut scores = HashMap::new();
|
|
scores.insert("Sunface", 98);
|
|
scores.insert("Daniel", 95);
|
|
scores.insert("Ashley", 69);
|
|
scores.insert("Katie", 58);
|
|
|
|
// get returns a Option<&V>
|
|
let score = scores.get("Sunface");
|
|
assert_eq!(score, Some(&98));
|
|
|
|
if scores.contains_key("Daniel") {
|
|
// indexing return a value V
|
|
let score = scores["Daniel"];
|
|
assert_eq!(score, 95);
|
|
scores.remove("Daniel");
|
|
}
|
|
|
|
assert_eq!(scores.len(), 3);
|
|
|
|
for (name, score) in scores {
|
|
println!("The score of {} is {}", name, score)
|
|
}
|
|
}
|
|
```
|
|
|
|
2.
|
|
|
|
```rust
|
|
use std::collections::HashMap;
|
|
fn main() {
|
|
let teams = [
|
|
("Chinese Team", 100),
|
|
("American Team", 10),
|
|
("France Team", 50),
|
|
];
|
|
|
|
let mut teams_map1 = HashMap::new();
|
|
for team in &teams {
|
|
teams_map1.insert(team.0, team.1);
|
|
}
|
|
|
|
let teams_map2: HashMap<_,_> = teams.into_iter().collect();
|
|
|
|
assert_eq!(teams_map1, teams_map2);
|
|
|
|
println!("Success!")
|
|
}
|
|
```
|
|
|
|
```rust
|
|
use std::{collections::HashMap};
|
|
fn main() {
|
|
let teams = [
|
|
("Chinese Team", 100),
|
|
("American Team", 10),
|
|
("France Team", 50),
|
|
];
|
|
|
|
let mut teams_map1 = HashMap::new();
|
|
for team in &teams {
|
|
teams_map1.insert(team.0, team.1);
|
|
}
|
|
|
|
let teams_map2 = HashMap::from(teams);
|
|
assert_eq!(teams_map1, teams_map2);
|
|
|
|
println!("Success!")
|
|
}
|
|
```
|
|
|
|
3.
|
|
|
|
```rust
|
|
// FILL in the blanks
|
|
use std::collections::HashMap;
|
|
|
|
fn main() {
|
|
// type inference lets us omit an explicit type signature (which
|
|
// would be `HashMap<&str, u8>` in this example).
|
|
let mut player_stats = HashMap::new();
|
|
|
|
// insert a key only if it doesn't already exist
|
|
player_stats.entry("health").or_insert(100);
|
|
|
|
assert_eq!(player_stats["health"], 100);
|
|
|
|
// insert a key using a function that provides a new value only if it
|
|
// doesn't already exist
|
|
player_stats.entry("health").or_insert_with(random_stat_buff);
|
|
assert_eq!(player_stats["health"], 100);
|
|
|
|
// Ensures a value is in the entry by inserting the default if empty, and returns
|
|
// a mutable reference to the value in the entry.
|
|
let health = player_stats.entry("health").or_insert(50);
|
|
assert_eq!(health, &100);
|
|
*health -= 50;
|
|
assert_eq!(*health, 50);
|
|
|
|
println!("Success!")
|
|
}
|
|
|
|
fn random_stat_buff() -> u8 {
|
|
// could actually return some random value here - let's just return
|
|
// some fixed value for now
|
|
42
|
|
}
|
|
```
|
|
|
|
4.
|
|
|
|
```rust
|
|
use std::collections::HashMap;
|
|
|
|
#[derive(Hash, Eq, PartialEq, Debug)]
|
|
struct Viking {
|
|
name: String,
|
|
country: String,
|
|
}
|
|
|
|
impl Viking {
|
|
/// Creates a new Viking.
|
|
fn new(name: &str, country: &str) -> Viking {
|
|
Viking {
|
|
name: name.to_string(),
|
|
country: country.to_string(),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
// Use a HashMap to store the vikings' health points.
|
|
let vikings = HashMap::from([
|
|
(Viking::new("Einar", "Norway"), 25),
|
|
(Viking::new("Olaf", "Denmark"), 24),
|
|
(Viking::new("Harald", "Iceland"), 12),
|
|
]);
|
|
|
|
// Use derived implementation to print the status of the vikings.
|
|
for (viking, health) in &vikings {
|
|
println!("{:?} has {} hp", viking, health);
|
|
}
|
|
}
|
|
```
|
|
|
|
5.
|
|
|
|
```rust
|
|
use std::collections::HashMap;
|
|
|
|
fn main() {
|
|
let v1 = 10;
|
|
let mut m1 = HashMap::new();
|
|
m1.insert(v1, v1);
|
|
println!("v1 is still usable after inserting to hashmap : {}", v1);
|
|
|
|
// &str implements Copy trait
|
|
let v2 = "hello";
|
|
let mut m2 = HashMap::new();
|
|
m2.insert(v2, v1);
|
|
|
|
assert_eq!(v2, "hello");
|
|
}
|
|
``` |