第8章: 一般的なコレクションと文字列

fn main() {
    // 空のベクタを作成（型注釈が必要な場合がある）
    let mut v: Vec<i32> = Vec::new();
    v.push(5);
    v.push(6);
    v.push(7);

    // vec!マクロを使うと型推論が効くため記述が楽
    let mut v2 = vec![1, 2, 3];
    v2.push(4);

    println!("v: {:?}", v);
    println!("v2: {:?}", v2);
    
    // popで末尾の要素を削除して取得（Optionを返す）
    let last = v2.pop();
    println!("Popped: {:?}", last);
    println!("v2 after pop: {:?}", v2);
}

fn main() {
    let v = vec![10, 20, 30, 40, 50];

    // 方法1: インデックス（確実に存在するとわかっている場合に使用）
    let third: &i32 = &v[2];
    println!("3番目の要素は {}", third);

    // 方法2: getメソッド（範囲外の可能性がある場合に使用）
    match v.get(100) {
        Some(third) => println!("101番目の要素は {}", third),
        None => println!("101番目の要素はありません"),
    }

    // イテレーション
    // &v とすることで所有権を移動させずに参照でループする
    print!("要素: ");
    for i in &v {
        print!("{} ", i);
    }
    println!();
    
    // 値を変更しながらイテレーション
    let mut v_mut = vec![1, 2, 3];
    for i in &mut v_mut {
        *i += 50; // 参照外し演算子(*)を使って値を書き換える
    }
    println!("変更後: {:?}", v_mut);
}

fn main() {
    let mut s = String::from("foo");
    s.push_str("bar"); // 文字列スライスを追加
    s.push('!');       // 1文字追加
    println!("{}", s);

    let s1 = String::from("Hello, ");
    let s2 = String::from("World!");
    
    // + 演算子を使用。
    // s1はムーブされ、以降使用できなくなることに注意
    // シグネチャは fn add(self, s: &str) -> String に近いため
    let s3 = s1 + &s2; 
    
    println!("{}", s3);
    // println!("{}", s1); // コンパイルエラー：s1はムーブ済み
    
    // format!マクロを使うと所有権を奪わず、読みやすく結合できる
    let s4 = String::from("tic");
    let s5 = String::from("tac");
    let s6 = String::from("toe");
    
    let s_all = format!("{}-{}-{}", s4, s5, s6);
    println!("{}", s_all);
}

fn main() {
    let s = "こんにちは"; // UTF-8で各文字3バイト

    // NG: s[0] はコンパイルエラー

    // 文字（char）として反復処理
    // RustのcharはUnicodeスカラ値（4バイト）
    print!("Chars: ");
    for c in s.chars() {
        print!("{} ", c);
    }
    println!();

    // バイトとして反復処理
    print!("Bytes: ");
    for b in s.bytes() {
        print!("{:x} ", b); // 16進数で表示
    }
    println!();
    
    // 部分文字列（スライス）の取得には範囲指定が必要
    // ただし、文字の境界に合わないバイトを指定すると実行時にパニックする
    let s_slice = &s[0..3]; // 最初の3バイト＝「こ」
    println!("Slice: {}", s_slice);
}

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();

    // 挿入
    scores.insert(String::from("Blue"), 10);
    scores.insert(String::from("Yellow"), 50);

    // 値の取得（getはOption<&V>を返す）
    let team_name = String::from("Blue");
    if let Some(score) = scores.get(&team_name) {
        println!("{}: {}", team_name, score);
    }

    // 反復処理（順序は保証されない）
    for (key, value) in &scores {
        println!("{}: {}", key, value);
    }
}

use std::collections::HashMap;

fn main() {
    let mut scores = HashMap::new();
    scores.insert(String::from("Blue"), 10);

    // 上書き（同じキーでinsertすると値は上書きされる）
    scores.insert(String::from("Blue"), 25);
    println!("Blue updated: {:?}", scores);

    // キーがない場合のみ挿入 (or_insert)
    scores.entry(String::from("Yellow")).or_insert(50);
    scores.entry(String::from("Blue")).or_insert(50); // 既に25があるので無視される
    println!("Entry check: {:?}", scores);

    // 既存の値に基づいて更新（単語の出現回数カウントなど）
    let text = "hello world wonderful world";
    let mut map = HashMap::new();

    for word in text.split_whitespace() {
        // or_insertは挿入された値への可変参照(&mut V)を返す
        let count = map.entry(word).or_insert(0);
        *count += 1; // 参照外ししてインクリメント
    }

    println!("Word count: {:?}", map);
}

fn main() {
    let numbers = vec![1, 10, 5, 2, 10, 5, 20, 5];


}

fn pig_latin(word: &str) -> String {
    // ここに変換ロジックを実装
    

}
fn main() {
    println!("{}", pig_latin("apple"));
    println!("{}", pig_latin("first"));
}