Rustで学ぶ！コレクションを活用した効率的なデータ変換と集約手法

let numbers = vec![1, 2, 3, 4, 5];
let mut iter = numbers.iter();

while let Some(value) = iter.next() {
    println!("{}", value);
}

   let numbers = vec![1, 2, 3];
   let doubled: Vec<_> = numbers.iter().map(|x| x * 2).collect();
   println!("{:?}", doubled); // [2, 4, 6]

   let numbers = vec![1, 2, 3, 4, 5];
   let evens: Vec<_> = numbers.iter().filter(|&&x| x % 2 == 0).collect();
   println!("{:?}", evens); // [2, 4]

let numbers = vec![1, 2, 3, 4, 5];
let result: Vec<_> = numbers
    .iter()
    .map(|x| x * 2)
    .filter(|x| x % 3 == 0)
    .collect();
println!("{:?}", result); // [6]

   let numbers = vec![1, 2, 3, 4, 5];
   let total: i32 = numbers.iter().sum();
   println!("Sum: {}", total); // Sum: 15

   let numbers = vec![1, 2, 3, 4];
   let product: i32 = numbers.iter().product();
   println!("Product: {}", product); // Product: 24

   let numbers = vec![1, 2, 3, 4, 5];
   let sum = numbers.iter().fold(0, |acc, &x| acc + x);
   println!("Sum using fold: {}", sum); // Sum using fold: 15

   let words = vec!["Rust", "is", "fast"];
   let sentence = words.iter().fold(String::new(), |mut acc, &word| {
       acc.push_str(word);
       acc.push(' ');
       acc
   });
   println!("{}", sentence.trim()); // Rust is fast

   let numbers = vec![10, 20, 5, 30];
   let max = numbers.iter().fold(i32::MIN, |acc, &x| acc.max(x));
   println!("Max value: {}", max); // Max value: 30

   let numbers = vec![1, 2, 3, 4, 5];
   let even_numbers: Vec<_> = numbers.iter().filter(|&&x| x % 2 == 0).collect();
   println!("{:?}", even_numbers); // [2, 4]

   let pairs = vec![("a", 1), ("b", 2), ("c", 3)];
   let map: std::collections::HashMap<_, _> = pairs.into_iter().collect();
   println!("{:?}", map); // {"a": 1, "b": 2, "c": 3}

   let data = vec![10, 20, 30, 40, 50];
   let sum: i32 = data.iter().sum();
   let avg = sum as f32 / data.len() as f32;
   println!("Average: {}", avg); // Average: 30.0

   let words = vec!["rust", "is", "fast", "rust", "is"];
   let mut counts = std::collections::HashMap::new();
   words.iter().for_each(|&word| {
       *counts.entry(word).or_insert(0) += 1;
   });
   println!("{:?}", counts); // {"rust": 2, "is": 2, "fast": 1}

   let numbers: Vec<_> = (1..1_000_000)
       .filter(|&x| x % 2 == 0)
       .take(10)
       .collect();
   println!("{:?}", numbers); // [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

   let numbers = vec![1, 2, 3, 4, 5];
   let doubled: Vec<_> = numbers.iter().map(|&x| x * 2).collect();
   println!("{:?}", doubled); // [2, 4, 6, 8, 10]

   let mut numbers = vec![1, 2, 3, 4, 5];
   let removed: Vec<_> = numbers.drain(0..2).collect();
   println!("Removed: {:?}", removed); // [1, 2]
   println!("Remaining: {:?}", numbers); // [3, 4, 5]

   use rayon::prelude::*;
   let numbers: Vec<_> = (1..1_000_000)
       .into_par_iter()
       .filter(|x| x % 2 == 0)
       .map(|x| x * 2)
       .collect();

   use std::fs::File;
   use std::io::{self, BufRead};
   fn main() -> io::Result<()> {
       let file = File::open("data.csv")?;
       let sum: i32 = io::BufReader::new(file)
           .lines()
           .filter_map(|line| line.ok()?.parse::<i32>().ok())
           .filter(|&x| x % 2 == 0)
           .sum();
       println!("Sum of even numbers: {}", sum);
       Ok(())
   }

   struct Employee {
       id: u32,
       name: String,
       position: String,
   }

   let employees = vec![
       Employee {
           id: 1,
           name: "Alice".to_string(),
           position: "Manager".to_string(),
       },
       Employee {
           id: 2,
           name: "Bob".to_string(),
           position: "Engineer".to_string(),
       },
   ];
   for employee in &employees {
       println!("{}: {}", employee.id, employee.name);
   }

   use std::collections::HashMap;
   let mut employee_map: HashMap<u32, Employee> = HashMap::new();
   employee_map.insert(
       1,
       Employee {
           id: 1,
           name: "Alice".to_string(),
           position: "Manager".to_string(),
       },
   );
   if let Some(employee) = employee_map.get(&1) {
       println!("Found: {} - {}", employee.id, employee.name);
   }

   #[derive(PartialEq, PartialOrd)]
   struct Employee {
       id: u32,
       name: String,
       position: String,
   }

   let mut employees = vec![
       Employee { id: 2, name: "Bob".to_string(), position: "Engineer".to_string() },
       Employee { id: 1, name: "Alice".to_string(), position: "Manager".to_string() },
   ];
   employees.sort_by(|a, b| a.id.cmp(&b.id));
   println!("{:?}", employees.iter().map(|e| &e.name).collect::<Vec<_>>()); // ["Alice", "Bob"]

   for employee in &employees {
       println!("Employee: {}", employee.name);
   }

   let managers: Vec<_> = employees
       .iter()
       .filter(|e| e.position == "Manager")
       .collect();

   use std::collections::HashMap;
   let mut grouped: HashMap<String, Vec<&Employee>> = HashMap::new();
   for employee in &employees {
       grouped.entry(employee.position.clone())
           .or_default()
           .push(employee);
   }
   println!("{:?}", grouped);

   use std::fmt;
   impl fmt::Display for Employee {
       fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
           write!(f, "{}: {} - {}", self.id, self.name, self.position)
       }
   }
   println!("{}", employees[0]);

   [dependencies]
   rayon = "1.7"

   use rayon::prelude::*;

   let numbers: Vec<i32> = (1..1_000_000).collect();
   let sum: i32 = numbers.into_par_iter().sum();
   println!("Sum: {}", sum);

   let numbers: Vec<i32> = (1..10).collect();
   let doubled: Vec<i32> = numbers.par_iter().map(|x| x * 2).collect();
   println!("{:?}", doubled); // [2, 4, 6, 8, 10, 12, 14, 16, 18]

   let numbers: Vec<i32> = (1..100).collect();
   let evens: Vec<i32> = numbers.par_iter().filter(|&&x| x % 2 == 0).cloned().collect();
   println!("{:?}", evens);

   let numbers: Vec<i32> = (1..10).collect();
   let product: i32 = numbers.par_iter().cloned().reduce(|| 1, |a, b| a * b);
   println!("Product: {}", product); // Product of 1..10

   use rayon::prelude::*;

   let numbers: Vec<i32> = (1..1_000_000).collect();
   let mean: f64 = numbers.par_iter().map(|&x| x as f64).sum::<f64>() / numbers.len() as f64;
   println!("Mean: {}", mean);

   use rayon::prelude::*;
   use std::collections::HashMap;

   let text = "rust is fast and safe. rust is great.";
   let word_counts: HashMap<&str, usize> = text
       .split_whitespace()
       .par_iter()
       .fold(|| HashMap::new(), |mut acc, &word| {
           *acc.entry(word).or_insert(0) += 1;
           acc
       })
       .reduce(|| HashMap::new(), |mut acc, map| {
           for (key, value) in map {
               *acc.entry(key).or_insert(0) += value;
           }
           acc
       });
   println!("{:?}", word_counts);

   fn parse_number(input: &str) -> Result<i32, std::num::ParseIntError> {
       input.parse::<i32>()
   }

   let result = parse_number("42");
   match result {
       Ok(n) => println!("Parsed number: {}", n),
       Err(e) => println!("Failed to parse: {}", e),
   }

   let values = vec![Some(1), None, Some(3)];
   let sum: i32 = values.iter().filter_map(|&x| x).sum();
   println!("Sum: {}", sum); // 4

   let inputs = vec!["10", "20", "invalid", "30"];
   let valid_numbers: Vec<i32> = inputs
       .iter()
       .filter_map(|&x| x.parse::<i32>().ok())
       .collect();
   println!("{:?}", valid_numbers); // [10, 20, 30]

   let inputs = vec!["10", "20", "invalid", "30"];
   let parsed: Result<Vec<_>, _> = inputs.iter().map(|&x| x.parse::<i32>()).collect();
   match parsed {
       Ok(numbers) => println!("Parsed numbers: {:?}", numbers),
       Err(e) => println!("Error occurred: {}", e),
   }

   let data = vec![Some(2), None, Some(4), None, Some(6)];
   let total: i32 = data.into_iter().flatten().sum();
   println!("Total: {}", total); // 12

   let data = vec![Some(2), None, Some(4)];
   let result: Vec<i32> = data.into_iter().map(|x| x.unwrap_or(0)).collect();
   println!("{:?}", result); // [2, 0, 4]

   use std::fs::File;
   use std::io::{self, BufRead};

   fn main() -> io::Result<()> {
       let file = File::open("data.csv")?;
       let sum: i32 = io::BufReader::new(file)
           .lines()
           .filter_map(|line| line.ok()?.parse::<i32>().ok())
           .sum();
       println!("Sum of valid numbers: {}", sum);
       Ok(())
   }

   let responses = vec![Some(200), None, Some(404), Some(500)];
   let default = 0;
   let valid_codes: Vec<i32> = responses.into_iter().map(|x| x.unwrap_or(default)).collect();
   println!("{:?}", valid_codes); // [200, 0, 404, 500]

   use std::error::Error;
   use csv::Reader;

   fn read_csv(file_path: &str) -> Result<Vec<Vec<String>>, Box<dyn Error>> {
       let mut reader = Reader::from_path(file_path)?;
       let mut records = Vec::new();
       for result in reader.records() {
           let record = result?;
           records.push(record.iter().map(String::from).collect());
       }
       Ok(records)
   }

   let data = read_csv("data.csv").expect("Failed to read CSV");
   println!("{:?}", data);

   let filtered_data: Vec<_> = data
       .into_iter()
       .filter(|row| row[2].parse::<f64>().unwrap_or(0.0) > 50.0) // 例: 3列目の値が50以上
       .map(|row| (row[0].clone(), row[1].clone())) // 例: 最初の2列を保持
       .collect();

   println!("{:?}", filtered_data);

   let summary: f64 = filtered_data
       .iter()
       .map(|(_, value)| value.parse::<f64>().unwrap_or(0.0))
       .sum();

   println!("Total Value: {}", summary);

   use std::fs::File;
   use std::io::Write;

   fn write_result(file_path: &str, data: &str) -> Result<(), Box<dyn Error>> {
       let mut file = File::create(file_path)?;
       file.write_all(data.as_bytes())?;
       Ok(())
   }

   write_result("output.txt", &format!("Total Value: {}", summary)).expect("Failed to write output");

use csv::Reader;
use std::fs::File;
use std::io::Write;
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    // データ読み込み
    let mut reader = Reader::from_path("data.csv")?;
    let mut filtered_data = Vec::new();

    // フィルタリングと変換
    for result in reader.records() {
        let record = result?;
        let value: f64 = record[2].parse().unwrap_or(0.0);
        if value > 50.0 {
            filtered_data.push((record[0].to_string(), record[1].to_string(), value));
        }
    }

    // 集約
    let total: f64 = filtered_data.iter().map(|(_, _, value)| *value).sum();
    println!("Total Value: {}", total);

    // 結果出力
    let mut file = File::create("output.txt")?;
    writeln!(file, "Filtered Data: {:?}", filtered_data)?;
    writeln!(file, "Total Value: {}", total)?;

    Ok(())
}