Collections & Strings

fn main() {
    let mut langs: Vec<String> = Vec::new();   // empty; the type is written out
    langs.push(String::from("rust"));
    langs.push(String::from("go"));
    langs.push(String::from("python"));

    let primes = vec![2, 3, 5, 7];              // vec! infers Vec<i32>
    let zeros = vec![0; 4];                     // four zeros

    println!("{:?} len={}", langs, langs.len());
    println!("{:?} {:?}", primes, zeros);
    println!("first={} last={:?}", primes[0], primes.last());

    let popped = langs.pop();                   // Option<String>
    println!("popped {:?}, left {:?}", popped, langs);
    langs.insert(0, String::from("c"));         // shifts everything right
    langs.remove(1);                            // shifts everything left
    println!("{:?} contains go? {}", langs, langs.contains(&String::from("go")));
}

fn main() {
    let scores = vec![90, 72, 85];
    for i in [1, 5] {
        match scores.get(i) {
            Some(s) => println!("scores[{i}] = {s}"),
            None => println!("no score at {i}"),
        }
    }
    println!("{}", scores.get(9).copied().unwrap_or(0));
}

fn main() {
    let mut prices = vec![100, 250, 40];

    for p in &prices {                 // read
        print!("{p} ");
    }
    println!();

    for p in &mut prices {             // change in place
        *p = *p * 110 / 100;           // * reaches the value behind the reference
    }
    println!("{:?}", prices);

    let names = vec![String::from("ada"), String::from("linus")];
    for name in names {                // take ownership of each String
        let shout = name.to_uppercase();
        println!("{shout}");
    }
    // names cannot be used here: the loop consumed it
}

fn average(xs: &[f64]) -> f64 {
    if xs.is_empty() {
        return 0.0;
    }
    xs.iter().sum::<f64>() / xs.len() as f64
}

fn main() {
    let temps = vec![21.0, 23.5, 19.0, 25.5, 22.0];
    let week = [1.0, 2.0, 3.0];                    // an array works too

    println!("all   {:.2}", average(&temps));
    println!("first {:.2}", average(&temps[..2]));  // elements 0 and 1
    println!("last3 {:.2}", average(&temps[2..]));
    println!("array {:.2}", average(&week));
    println!("empty {:.2}", average(&[]));

    let mut sorted = temps.clone();
    sorted.sort_by(|a, b| a.partial_cmp(b).unwrap()); // f64 has no total order
    println!("{:?}", sorted);
    let (low, high) = sorted.split_at(2);
    println!("low {:?} high {:?}", low, high);
}

fn greet(name: &str) -> String {
    format!("Hello, {name}!")               // format! builds a new String
}

fn main() {
    let literal: &str = "world";            // baked into the program
    let owned: String = String::from("Ada");

    println!("{}", greet(literal));
    println!("{}", greet(&owned));          // &String coerces to &str

    let mut log = String::new();
    log.push_str("GET /");                  // append a &str
    log.push(' ');                          // append one char
    log.push_str("200");
    log += " OK";                           // += also takes a &str
    println!("{log} ({} bytes)", log.len());

    let csv = ["a", "b", "c"].join(",");
    let id = 42.to_string();
    println!("{csv} {id} {}", "  padded  ".trim());
}

fn main() {
    let s1 = String::from("tic");
    let s2 = String::from("tac");
    let s3 = s1 + "-" + &s2;        // s1 moved into s3; s2 borrowed
    println!("{s3}");
    println!("{s2} still usable");

    let a = String::from("x");
    let b = String::from("y");
    let c = format!("{a}-{b}-{a}");  // borrows only
    println!("{c} {a} {b}");
}

fn main() {
    let word = "café";
    println!("bytes: {}  chars: {}", word.len(), word.chars().count());

    for c in word.chars() {
        print!("[{c}]");
    }
    println!();

    for b in word.bytes() {
        print!("{b} ");
    }
    println!();

    for (i, c) in word.char_indices() {     // byte offset of each char
        print!("{i}:{c} ");
    }
    println!();

    println!("{}", &word[0..3]);             // bytes 0..3 = "caf", safe
    let reversed: String = word.chars().rev().collect();
    println!("{reversed} {}", word.to_uppercase());
}

use std::collections::HashMap;

fn main() {
    let mut stock: HashMap<String, u32> = HashMap::new();
    stock.insert(String::from("apple"), 5);
    stock.insert(String::from("pear"), 2);
    stock.insert(String::from("apple"), 7);      // same key: value replaced

    println!("apples: {:?}", stock.get("apple"));
    println!("kiwis:  {:?}", stock.get("kiwi"));
    println!("pears or 0: {}", stock.get("pear").copied().unwrap_or(0));
    println!("has pear? {} len={}", stock.contains_key("pear"), stock.len());

    if let Some(n) = stock.get_mut("pear") {
        *n += 10;
    }
    stock.remove("apple");

    let mut keys: Vec<_> = stock.keys().collect();
    keys.sort();                                  // fixed order for printing
    for k in keys {
        println!("{k} -> {}", stock[k]);
    }
}

use std::collections::HashMap;

fn main() {
    let text = "the cat sat on the mat the end";
    let mut counts: HashMap<&str, usize> = HashMap::new();

    for word in text.split_whitespace() {
        *counts.entry(word).or_insert(0) += 1;
    }

    // Sort by count (highest first), then alphabetically for ties
    let mut pairs: Vec<(&str, usize)> = counts.into_iter().collect();
    pairs.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(b.0)));
    for (word, n) in &pairs {
        println!("{word:<4} {n}");
    }

    // Group words by their first letter
    let mut groups: HashMap<char, Vec<&str>> = HashMap::new();
    for word in ["apple", "avocado", "banana", "blueberry", "cherry"] {
        let first = word.chars().next().unwrap();
        groups.entry(first).or_default().push(word);
    }
    let mut letters: Vec<_> = groups.keys().copied().collect();
    letters.sort();
    for c in letters {
        println!("{c}: {:?}", groups[&c]);
    }
}

use std::collections::{BTreeMap, HashSet, VecDeque};

fn main() {
    // HashSet: unique values, fast "have I seen this?"
    let visits = ["home", "docs", "home", "blog", "docs", "home"];
    let unique: HashSet<&str> = visits.iter().copied().collect();
    println!("{} unique pages, seen blog? {}", unique.len(), unique.contains("blog"));

    let a: HashSet<i32> = [1, 2, 3, 4].into_iter().collect();
    let b: HashSet<i32> = [3, 4, 5].into_iter().collect();
    let mut both: Vec<_> = a.intersection(&b).copied().collect();
    both.sort();
    println!("in both: {:?}", both);

    // BTreeMap: always iterates in key order
    let mut grades = BTreeMap::new();
    grades.insert("maya", 88);
    grades.insert("ali", 93);
    grades.insert("zoe", 71);
    println!("{:?}", grades);
    println!("first: {:?}", grades.first_key_value());

    // VecDeque: a first-in, first-out queue
    let mut queue = VecDeque::new();
    queue.push_back("job1");
    queue.push_back("job2");
    queue.push_front("urgent");
    while let Some(job) = queue.pop_front() {
        print!("{job} ");
    }
    println!();
}