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

0x0f1

Paul4673

a day 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 days 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

3 days 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

3 days 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

5 days 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

12 days 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

13 days 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

13 days 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

16 days 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

19 days 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

20 days 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

20 days 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

22 days 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

22 days 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

23 days 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

a month 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

2 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(())
    }
}

Splatrac

splatrac

2 months ago

7.60ms

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 f = File::create_new(path)?;
        let logs = &self.search(keyword);
        for log in logs {
            f.write_all(log.as_bytes())?;
            f.write_all("\n".as_bytes())?;
        }
        Ok(())
    }
}

Davide Butera

davide-butera

2 months ago

5.30ms

90.73kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
use std::{fs::File, 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 mut file = File::create(path)?;
        let logs = self.search(keyword);
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Nelly Whads

NellyWhads

2 months 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 mut file = File::create(path)?;
        let results = self.search(keyword);
        for line in results {
            file.write_all(line.as_bytes())?;
            file.write_all(b"\n")?;
        }
        Ok(())
    }
}

FinitelyFailed

2 months ago

6.33ms

90.73kb

use std::io::Write;
use std::fs::File;
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 result in self.search(keyword) {
            writeln!(file, "{}", result)?;
        }
        Ok(())
    }
}

Yash Rawat

Yash-Rawat-IIT-D

2 months ago

5.92ms

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 fhandler = File::create(path)?;
        let filtered_logs = self.search(keyword);
        for log in filtered_logs {
            writeln!(fhandler,"{}",log)?;
        }
        Ok(())
    }
}

Khalifa

e1ec30

2 months ago

8.00ms

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 {
            writeln!(file, "{}", result)?;
        }
        Ok(())
    }
}

Pedro Diaz

pdiaz

2 months ago

8.25ms

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::options()
            .create(true)
            .append(true)
            .open(path)?;
        self.search(keyword)
            .iter()
            .try_for_each(|s| writeln!(file, "{}", s))
    }
}

SalazarTh

2 months ago

7.81ms

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! 🎁
        std::fs::File::create(path)?
        .write_all(&self.search(keyword)
        .iter()
        .map(|&item| item.as_bytes())
        .collect::<Vec<&[u8]>>()
        .join("\n".as_bytes()) 
        )
    }
}

EchosinEchos

2 months ago

9.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<()> {
        // 🎁 Your code here! 🎁
        File::create(path)?
        .write_all(
            &self.search(keyword)
            .iter()
            .map(|x| x.as_bytes())
            .collect::<Vec<&[u8]>>()
            .join("\n".as_bytes()))
    }
}

huanderer

3 months ago

7.19ms

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 contents = self.search(keyword);
        let mut file = File::create(path)?;
        for log in contents {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Owen Shepherd

414owen

3 months ago

5.31ms

96.94kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    #[inline(always)]
    fn search2(&self, keyword: &'a str) -> impl Iterator<Item=&'a String> + '_ {
        self.logs
            .iter()
            .filter(move |log| log.contains(keyword))
    }
    pub fn search(&self, keyword: &'a str) -> Vec<&'a String> {
        self
            .search2(keyword)
            .collect()
    }
    pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
        use std::io::{BufWriter, Write};
        use std::fs::File;
        let mut file = BufWriter::new(File::create(path)?);
        for s in self.search2(keyword) {
            file.write_all(s.as_bytes())?;
            file.write_all("\n".as_bytes())?;
        }
        Ok(())
    }
}

Owen Shepherd

414owen

3 months ago

5.69ms

90.73kb

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

Owen Shepherd

414owen

3 months ago

6.91ms

90.73kb

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

Owen Shepherd

414owen

3 months ago

6.42ms

90.73kb

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

Owen Shepherd

414owen

3 months ago

5.85ms

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<()> {
        use std::io::Write;
        let mut file = std::fs::File::create(path)?;
        for s in self.search(keyword) {
            writeln!(file, "{}", s)?;
        }
        Ok(())
    }
}

David Phillips

Zantier

3 months ago

5.44ms

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 results = self.search(keyword);
        let mut f = File::create(path)?;
        for result in results {
            f.write_all(result.as_bytes())?;
            f.write_all("\n".as_bytes())?;
        }
        Ok(())
    }
}

Reinhard Langner

ReneCode

3 months ago

6.07ms

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 result = self.search(keyword);
        let mut file = std::fs::File::create(path)?;
        for log in result {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Markus

Maroko1218

3 months ago

4.93ms

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) {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

Paolo Cancedda

Pac72

3 months ago

5.69ms

90.73kb

use std::io::Write;
use std::fs::File;
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 filtered_logs = Self::search(&self, keyword);
        let mut file = File::create(path)?;
        for log in filtered_logs {
            match file.write(log.as_bytes()) {
                std::io::Result::Ok(_) => (),
                std::io::Result::Err(ee) => return Err(ee),
            }
            match file.write("\n".as_bytes()) {
                std::io::Result::Ok(_) => (),
                std::io::Result::Err(ee) => return Err(ee),
            }
        }
        Ok(())
    }
}

mednson

Mednson

3 months ago

6.01ms

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(())
    }
}

Aurimas Kuniutis

auriku

3 months ago

5.74ms

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 buffer = File::create(path)?;
        
        for log in self.search(keyword) {
            buffer.write_all(log.as_bytes())?;
            buffer.write_all(b"\n")?;
        }
        
        Ok(())
    }
}

NewGyu

3 months ago

6.17ms

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<()> {
        use std::fs::File;
        use std::io::{Result, Write};
        let logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in logs {
            writeln!(file, "{}", log)?;
        }
        Result::Ok(())
    }
}

mroslander

3 months ago

6.39ms

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 lines = self.search(keyword);
        let mut file = File::create(path)?;
        for line in lines {
            writeln!(file, "{}", line)?;
        }
        return Ok(())
    }
    //  pub fn export_to_file(&self, keyword: &str, path: &str) -> std::io::Result<()> {
    //     let logs = self.search(keyword);
    //     let mut f = File::create(path)?;
    //     for &log in logs.iter() {
    //         f.write_all(format!("{}\n", log).as_bytes())?;
    //     }
    //     return Ok(())
    // }
}

nalyD

nalyDylan

3 months ago

5.42ms

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 output_file = File::create(path);
        match output_file {
            Ok(mut file) => Ok(self.write_file(&mut file, logs)),
            Err(err) => Err(err)
        }
    }
    fn write_file(&self, file: &mut File, logs: Vec<&'a String>) {
        for log_line in logs {
            writeln!(file, "{}", log_line);
        }
    }
}

theodoorscholte

3 months ago

6.58ms

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(()) 
    }
}