Day 8: Blitzen's Debug Blitz

The North Pole’s DevOps room was unusually quiet—well, as quiet as it could be with Blitzen strutting around like he owned the place. The reindeer had declared himself Tech Lead™ (again), and with Santa still off on his "vision quest", nobody had dared challenge him. Every five minutes, Blitzen would casually remind the room, "I’m the Tech Lead, in case anyone forgot."

The elves, however, had not forgotten. Frostbyte, the team’s fastest typist, was already regretting showing up for work today.

The Discovery of Errors

It all started when Blitzen stumbled upon a string of unusual log entries:

ERROR: Toy Tracker 3000 overheating.
ERROR: SleighOS failed to authenticate.
ERROR: Reindeer AI unable to locate Prancer.

He squinted at the terminal, his antlers practically buzzing with excitement. “This… this is big,” Blitzen declared dramatically. “These errors need to be isolated, analyzed, and stored in their own file. This could save Christmas!”

Prancer, barely looking up from their desk, muttered, “Couldn’t we just pipe the logs through grep ERROR and append it to a file with >> file.log?”

Blitzen whipped around, scandalized. “Prancer, what part of 'I’m the Tech Lead' didn’t you understand? We don’t use grep here. We build solutions. Innovative solutions. In Rust!”

“Here’s the plan,” Blitzen said, pacing like a founder pitching to VCs. “We’ll extend our LogQuery tool to not just search logs, but also export specific entries to a file. A Rustacean-grade solution, not some bash script hack job.”

An elf raised their hand timidly. “But why?”

Blitzen grinned. “Because I’m the Tech Lead.”

Your Mission

You must come to the elves rescue! Implement the export_to_file(&self, keyword: &str, file_path: &str) method in LogQuery that:

Use the search method we created earlier to get logs matching the keyword.
Loop over the returned logs and write them to a file, the location is given by the parameter path.
Handles Errors: If the file can’t be created or written to, the function should return an appropriate error instead of crashing.

Hints

If you’re stuck or need a starting point, here are some hints to help you along the way!

Click here to show hints.

Make sure you import the necessary modules. e.g., use std::{fs::File, io::Write};.
Get the logs using the search method we created in the previous challenge. e.g. let logs = self.search(keyword);.
Create a mutable file using File::create. e.g. let mut file = File::create(path)?;
Properly handle errors with Result and ? to propagate them.
Loop over the logs and use the writeln! macro to write to the file. e.g.
```
for log in logs {
    writeln!(file, "{}", log)?;
}
```
Return Ok(()) if everything goes well.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Prashant Puri

Prashant-dot1

9 days ago

5.40ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let logs_matched = self.search(keyword);
        // creating a file on the provided path
        let mut file = File::create(path)?;
        for log in logs_matched {
            file.write(format!("{}\n",log).as_bytes())?;
        }
        Ok(())
    }
}

Heino Mortensen

hmortensen83

12 days ago

6.44ms

90.73kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let logs = self.search(keyword);
        std::fs::write(
            path,
            logs.iter()
                .map(|s| s.as_str())
                .collect::<Vec<_>>()
                .join("\n"),
        )
    }
}

Spheniscine

18 days ago

5.74ms

90.73kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        use std::fs::File; 
        use std::io::Write;
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in logs {
            writeln!(&mut file, "{}", log)?;
        }
        Ok(())
    }
}

Andreas Lundin

andreaslundin47

19 days ago

5.50ms

90.73kb

use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let logs = self.search(keyword);
        let mut file = std::fs::File::create(path)?;
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

visanr

20 days ago

5.49ms

90.73kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
use std::fs::File;
use std::io::Write;
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in logs {
            writeln!(file, "{}", log);
        }
        Ok(())
        // 🎁 Your code here! 🎁
    }
}

palcoo42

21 days ago

6.95ms

96.97kb

use std::{
    fs::File,
    io::{BufWriter, Write},
};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let logs = self.search(keyword);
        let file = File::create(path)?;
        let mut writer = BufWriter::new(file);
        for log in logs {
            writeln!(writer, "{log}")?;
        }
        Ok(())
    }
}

Camiam144

22 days ago

5.06ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 
        let logs = self.search(keyword);        
        let mut file = File::create(path)?;
        for log in logs {
            writeln!(file, "{}", log)?;
        }
       Ok(()) 
    }
}

angalar

22 days ago

5.12ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in logs {
            writeln!(file, "{log}")?;
        }
        Ok(())
    }
}

Khant

Khantdotcom

23 days ago

9.93ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in logs{
            writeln!(file,"{}",log)?;
        }
        Ok(())
    }
}

johndoe30bc

23 days ago

5.76ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let mut f = File::create(path)?;
        for log in self.search(keyword) {
            writeln!(f, "{log}")?;
        }
        
        Ok(())
    }
}

Wouter

WouterMartens

24 days ago

5.98ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let mut file = File::create(path)?;
        for log in self.search(keyword) {
            write!(file, "{log}\n")?;
        }
        Ok(())
    }
}

Robert Linnemann

mevdev

a month ago

6.68ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        
        Ok(())
    }
}

Guilherme

GuilhermeGcaires

a month ago

5.10ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Youssef Bennour Sahli

youssefbennour

a month ago

6.04ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let mut file = File::create(path)?;
        let logs = self.search(keyword);
        for log in logs{
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

sjmellor

a month ago

6.37ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let mut file = File::create(path)?;
        let logs = self.search(keyword);
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Chloe

chloecat34

a month ago

6.56ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let mut file = File::create(path)?;
        let logs = self.search(keyword);
        for log in logs {
            write!(file, "{log}\n")?;
        }
        Ok(())
    }
}

tdoan

a month ago

5.40ms

90.73kb

use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let search_results = self.search(keyword);
        let mut file = std::fs::File::create(path)?;
        for log in search_results.iter() {
            writeln!(file, "{}", log);
        }
        Ok(())
      }
}

brucecox01

a month ago

5.94ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Sergey Chelak

SergeyChelak

a month ago

6.00ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let mut file = File::create(path)?;
        for log in self.search(keyword).iter() {
            file.write_all(log.as_bytes())?;
            file.write_all("\n".as_bytes())?;
        }
        Ok(())
    }
}

Andrés Pérez

cperez08

a month ago

6.51ms

90.73kb

use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let logs: Vec<&'a String> = self.search(keyword);
        let mut file = match std::fs::OpenOptions::new()
            .create(true)
            .append(true)
            .open(path)
        {
            Ok(f) => f,
            Err(e) => return Err(e),
        };
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Neon-Panda

2 months ago

5.60ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

helgesander

2 months ago

5.26ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let mut file = File::create(path)?;
        self.search(keyword).iter().for_each(|log| {
            writeln!(file, "{}", log).unwrap();
        });
        Ok(())
    }
}

Felix

FelixMaetzler

2 months ago

5.47ms

90.73kb

use std::{fs, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let mut f = fs::File::create(path)?;
        for log in self.search(keyword) {
            writeln!(f, "{log}")?;
        }
        Ok(())
    }
}

Philippe Massicotte

PMassicotte

2 months ago

5.21ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        for line in logs {
            writeln!(file, "{line}")?;
        }
        Ok(())
    }
}

UncleScientist

2 months ago

6.48ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let mut file = File::create(path)?;
        for line in self.search(keyword) {
            writeln!(file, "{line}")?;
        }
        Ok(())
    }
}

0x0f1

Paul4673

2 months ago

6.00ms

90.73kb

use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let logs = self.search(keyword);
        let mut file = std::fs::File::create(path)?;
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Kristupas Arifovas

Quikmove

2 months ago

5.66ms

90.73kb

use std::{fs::File,io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let mut f = File::create(path)?;
        let logs = self.search(keyword);
        for log in logs {
            writeln!(f, "{}", log)?;
        }
        Ok(())
    }
}

AncientSecrets

2 months ago

5.07ms

90.73kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        use std::io::Write;
        let mut file = std::fs::File::create(path)?;
        for log in self.search(keyword) {
            writeln!(file, "{log}")?;
        }
        Ok(())
    }
}

HubertBL47

2 months ago

7.02ms

90.73kb

use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let mut file = std::fs::File::create(path)?;
        for log in self.search(keyword) {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

silaskoemen

2 months ago

4.94ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Hongzhii

2 months ago

5.29ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let target_logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in target_logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Luigi Terrone

LuigiTer

2 months ago

5.46ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let mut file = File::create(path)?;
        let logs: Vec<&'a String> = self.search(keyword);
        for log in logs {
            writeln!(file, "{}", log)?;
        } 
        Ok(())
    }
}

xian ma

xanvcs

2 months ago

5.42ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let exports = self.search(keyword);
        let mut file = File::create(path)?;
        for item in exports {
            writeln!(file, "{}", item).expect("Unable to write to file");
        }
        
        Ok(())
    }
}

13Noodles

2 months ago

4.77ms

90.73kb

use std::{fs, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let mut f = fs::File::create(path)?;
        for log in self.search(keyword) {
            writeln!(f, "{}", log)?;
        }
        return Ok(());
    }
}

hoslo

2 months ago

5.75ms

90.73kb

use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let logs = self.search(keyword);
        let mut f = std::fs::OpenOptions::new().create(true).write(true).open(path)?;
        for log in logs {
            writeln!(f, "{}", log)?;
        }
        Ok(())
    }
}

zeitnut

2 months ago

4.96ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let mut file = File::create(path)?;
        let matches = self.search(keyword);
        // Won't work as closure must return () not Result
        // matches.iter().for_each(|line| writeln!(file, "{line}"));
        for line in matches {
            writeln!(file, "{line}")?;
        }
        Ok(())
    }
}

Adrian

GiantDole

2 months ago

5.48ms

90.73kb

use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let findings = self.search(keyword);
        let mut file = std::fs::File::create(path)?;
        for data in findings {
            writeln!(file, "{}", data)?;
        }
        Ok(())
    }
}

NataliaBromyrska

2 months ago

6.79ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

DFC-Siege

2 months ago

5.89ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let mut file = File::create(path)?;
        for log in self.search(keyword) {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

yuiidev

2 months ago

6.55ms

90.73kb

use std::{fs::File, io::Result, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> Result<()> {
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        
        for log in logs {
            file.write_all(format!("{}\n", log).as_bytes())?;
        }
        
        Ok(())
    }
}

charles lohest

cnikov

3 months ago

8.36ms

96.97kb

use std::fs::File;
use std::io::BufWriter;
use std::io::prelude::*;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let mut file = BufWriter::new(File::create(path)?);
        let nl = [b'\n'];
        for line in self.search(keyword) {
            let _ = file.write(line.as_bytes())?;
            let _ = file.write(&nl);
        }
        file.flush()?;
        Ok(())
    }
}

Holger Knauer

hknauer

3 months ago

5.80ms

96.97kb

use std::fs::File;
use std::io::BufWriter;
use std::io::prelude::*;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let mut file = BufWriter::new(File::create(path)?);
        let nl = [b'\n'];
        for line in self.search(keyword) {
            let _ = file.write(line.as_bytes())?;
            let _ = file.write(&nl);
        }
        file.flush()?;
        Ok(())
    }
}

diucicd

3 months ago

6.92ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let logs = self.search(keyword);
        let mut file = File::create_new(path)?;
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Erik Hollembeak

futureperfect

3 months ago

5.99ms

97.00kb

use std::{fs::File, io::{BufWriter, Write}};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let file = File::create(path)?;
        let mut writer = BufWriter::new(file);
        for line in self.search(keyword) {
            let bytes_with_newline = [line.as_bytes(), b"\n"].concat();
            writer.write_all(&bytes_with_newline).expect("Error writing to file");
        }
        writer.flush()?;
        Ok(())
    }
}

Erik Hollembeak

futureperfect

3 months ago

4.86ms

97.00kb

use std::{fs::File, io::{BufWriter, Write}};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let file = File::create(path)?;
        let mut writer = BufWriter::new(file);
        for line in self.search(keyword) {
            let bytes_with_newline = [line.as_bytes(), b"\n"].concat();
            writer.write_all(&bytes_with_newline).expect("Error writing to file");
        }
        writer.flush()?;
        Ok(())
    }
}

Erik Hollembeak

futureperfect

3 months ago

6.15ms

96.97kb

use std::{fs::File, io::{BufWriter, Write}};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let file = File::create(path)?;
        let mut writer = BufWriter::new(file);
        for line in self.search(keyword) {
            writer.write_all(line.as_bytes()).expect("Error writing to file");
            writer.write_all(b"\n").expect("Error writing newline");
        }
        writer.flush()?;
        Ok(())
    }
}

illay123

3 months ago

8.09ms

90.73kb

use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        let logs = self.search(keyword);
        let mut file = std::fs::File::create(path)?;
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

deo2407

3 months ago

5.67ms

90.73kb

use std::fs;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let found = self.search(keyword);
        let content = found
            .iter()
            .map(|x| x.as_str())
            .collect::<Vec<&str>>()
            .join("\n");
        fs::write(path, content)?;
        Ok(())
    }
}

David Phillips

Zantier

3 months ago

5.98ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let results = self.search(keyword);
        let mut file = File::create(path)?;
        for result in results {
            file.write_all(result.as_bytes())?;
            file.write_all(b"\n")?;
        }
        Ok(())
    }
}

Viwaswat Raj Singh

viwaswatraj

3 months ago

5.45ms

90.73kb

use std::fs::File;
use std::io::Write;
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        // 🎁 Your code here! 🎁
        let logs = &self.search(keyword);
        let mut buffer = File::create(path)?;
        for log in logs {
            writeln!(buffer, "{}", log)?;
        }
        Ok(())
    }
}