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

FredoPo

4 days ago

11.00ms

90.73kb

use std::{fs::File, io::Write};
pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
// 3. Create a public method named `search` that accepts a string slice and finds it from the logs and
//    returns a vector of references to those 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 = File::create(path).map_err(|_| "Erreur");
        let mut f = File::create(path)?;
        for log in logs {
            writeln!(f, "{log}")?;
        }
        Ok(())
    }
}

SilentCanon

silentcanon

6 days ago

6.51ms

90.73kb

use std::fs::File;
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 logs = self.search(keyword);
        let mut file = File::create(path)?;
        for log in logs {
            file.write_all(log.as_bytes())?;
            file.write_all(b"\n")?
        }
        file.flush()?;
        Ok(())
    }
}

anjanimaurya

8 days ago

5.55ms

90.73kb

use std::fs::File;
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 logs = self.search(keyword);
        match File::options().create(true).write(true).open(path){
            Ok(mut f) => {
                for log in logs.iter(){
                    writeln!(f, "{}", log);                    
                }
                return Ok(());
            }
            Err(er) => return Err(er),
        }
    }
}

Christopher Nielson

c-nielson

10 days ago

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

Yi Hao

leongyihao

10 days ago

6.51ms

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<()> {
		let mut file = fs::File::create(path)?;
		let logs = self.search(keyword);
		logs.iter().for_each(|item| {
			write!(file, "{item}\n");
		});
		Ok(())
    }
}

rponcepore

10 days ago

5.83ms

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 {
        file.write_all(log.as_bytes())?;
        file.write_all(b"\n")?;
      }
      
      Ok(())
  }
}

avilikof

13 days ago

4.96ms

90.73kb

use std::fs::OpenOptions;
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 search_result = self.search(keyword);
        // Open or create new file form path
        let mut file = OpenOptions::new()
            .read(true)
            .write(true)
            .create(true)
            .truncate(true)
            .open(path)?;
        let content: String = search_result
            .iter()
            .map(|s| s.as_str()) // Convert &String to &str
            .collect::<Vec<&str>>() // Collect into Vec<&str>
            .join("\n"); // Join with newlines
        file.write_all(content.as_bytes())?;
        Ok(())
    }
}

Chess Luo

chessl

23 days ago

8.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 line in logs {
            file.write(format!("{}\n", line).as_bytes())?;
        }
        Ok(())
    }
}

codervijo

23 days ago

5.75ms

90.73kb

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

Leandro Abreu

leandronowras

25 days ago

6.53ms

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

Alex Ioannidis

slint

a month ago

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

zitro

0zitro

a month ago

5.67ms

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 matches: Vec<String> = self.search(keyword).into_iter().map(|s| s.clone()).collect();
        let mut file_handle = File::create(path)?;
        file_handle.write_all(matches.join("\n").as_bytes())
    }
}

Erik Werner

rikner

a month ago

16.49ms

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 relevant_logs = self.search(keyword);
        for log in relevant_logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

William Chu

uptickmetachu

a month 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 output = File::create(path)?;
        for log in logs {
            writeln!(output, "{}", log)?
        }
        Ok(())
    }
}

adli daffa

addffa

a month ago

6.14ms

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

aey4

a month ago

5.31ms

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

viky

vikyw89

a month ago

5.43ms

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 searched_logs = self
            .search(keyword)
            .iter()
            .map(|log| log.as_str())
            .collect::<Vec<&str>>();
        std::fs::write(path, searched_logs.join("\n"))
    }
}

Stefan Toman

stoman

a month ago

4.88ms

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)?;
        for log in self.search(keyword) {
            writeln!(file, "{}", log).expect("can't write to file");
        }
        Ok(())
    }
}

KamiTrades

kamixbt

a month ago

4.66ms

90.73kb

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

Jonathan

tato123

a month ago

5.36ms

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

Zeel Darji

zeel991

a month ago

8.63ms

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

Romain Perier

rperier

a month ago

31.23ms

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

Bob Schmertz

rschmertz

a month ago

7.48ms

90.73kb

use std::fs::File;
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 = match File::create(&path) {
            Err(why) => return Err(why),
            Ok(file) => file,
        };
        //let mut result = Result::Ok();
        /*
        for &x in self.search(&keyword).iter() {
            let result: std::io::Result<()> = match file.write(x.as_bytes()) {
                Err(why) => return Err(why),
                Ok(x) => Ok(()),
            };
        };
        */
        let errlog = self.search(&keyword).iter().map(|s| s.as_str())
              .collect::<Vec<&str>>().join("\n");
        match file.write(errlog.as_bytes()) {
            Err(why) => return Err(why),
            Ok(x) => Ok(()),
        }
        //file.close()
    }
}

Y.

klllr

a month ago

5.20ms

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 buf = File::create(path)?;
        for l in logs {
            write!(buf, "{}\n", l)?;
        }
        buf.flush()?;
        Ok(())
    }
}

Derek Chen-Becker

dchenbecker

a month ago

6.55ms

96.97kb

use std::fs::File;
use std::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 results = self.search(keyword);
        let mut output = BufWriter::new(File::create(path)?);
        for line in results {
            output.write_all(line.as_bytes())?;
            output.write("\n".as_bytes())?;
        }
        Ok(())
    }
}

Yossa Bourne

terminox

a month ago

12.57ms

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

Peter Schols

pschols

a month ago

6.78ms

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

Bambalam

bambalamm

a month ago

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

Juniper

user32121

a month ago

6.17ms

90.73kb

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

Antoine Plard

tylp

a month ago

5.15ms

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

Sergei Chertkov

mamont

a month ago

5.64ms

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 loglines = self.search(keyword);
        loglines.iter().try_for_each(|log| writeln!(file, "{}", log))
    }
}

Hendrik Jennen

hendriko373

a month ago

6.04ms

90.73kb

use std::fs;
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 content = self.search(keyword).iter().fold(String::new(), |acc, &s| acc + s.as_str() + "\n");
        let mut f = fs::File::create(path)?;
        f.write_all(&content.as_bytes())
    }
}

Omar Saber Talaat Abdelrahman

omar-s-ta

a month ago

5.43ms

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<()> {
        let wanted_logs = self
            .search(keyword)
            .iter()
            .map(|str| str.to_string())
            .collect::<Vec<_>>()
            .join("\n");
        std::fs::write(path, wanted_logs)
    }
}

Omar Saber Talaat Abdelrahman

omar-s-ta

a month ago

5.83ms

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 wanted_logs = self.search(keyword);
        for log in wanted_logs {
            writeln!(file, "{}", log)?;
        }
        Ok(())
    }
}

acesolucoes

a month ago

5.67ms

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

Helene Semb

HelenSem723

a month ago

6.85ms

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)?;
}
        // 🎁 Your code here! 🎁
        Ok(())
    }
}

Benry Bytes

benrybytes

a month ago

4.74ms

90.73kb

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

Job Matheka

jobm

a month ago

4.77ms

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<()> {
        let logs = self
            .search(keyword)
            .iter()
            .map(|line| line.to_string())
            .collect::<Vec<_>>()
            .join("\n");
        std::fs::write(path, logs)
    }
}

mliertzer

a month ago

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

Pumkko

a month ago

40.72ms

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

João Paiva

jgpaiva

a month ago

7.23ms

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 v = self.search(keyword);    
        
use std::io::prelude::*;
        let mut file = std::fs::File::create(path)?;
            for v in v {
        file.write_all(v.as_bytes())?;
        file.write_all(b"\n");
        }
        Ok(())
    }
}

Masashi Nakayasu

MCsamurai034

a month ago

7.01ms

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 mut file = std::fs::OpenOptions::new()
                        .append(true)
                        .create(true)
                        .open(path)?;
        let matched_logs: Vec<&String> = LogQuery::search(self, keyword);
        for l in matched_logs {
            file.write_all(l.as_bytes())?;
            file.write_all(b"\n")?;
        }
        Ok(())
    }
}

Masashi Nakayasu

MCsamurai034

a month ago

5.52ms

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 mut file = std::fs::OpenOptions::new()
                        .append(true)
                        .create(true)
                        .open(path)?;
        let matched_logs: Vec<&String> = LogQuery::search(self, keyword);
        for l in matched_logs {
            file.write_all(l.as_bytes())?;
            file.write_all(b"\n")?;
        }
        Ok(())
    }
}

Masashi Nakayasu

MCsamurai034

a month ago

28.34ms

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 mut file = std::fs::OpenOptions::new()
                        .append(true)
                        .create(true)
                        .open(path)?;
        let matched_logs: Vec<&String> = LogQuery::search(self, keyword);
        for l in matched_logs {
            file.write_all(l.as_bytes())?;
            file.write_all(b"\n")?;
        }
        Ok(())
    }
}

isaaclv

a month ago

5.63ms

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

Mingzhe Yang

mei28

2 months ago

5.51ms

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 matches = self.search(keyword);
        matches
            .into_iter()
            .map(|k| writeln!(file, "{}", k))
            .collect::<std::io::Result<()>>()
    }
}

PangoSea

kapaseker

2 months ago

5.49ms

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).iter().map(|arg: &&String| String::as_str(*arg)).collect::<Vec<_>>().join("\n");
        std::fs::write(path, logs)
    }
}

Harald Gliebe

hagl

2 months ago

5.96ms

90.73kb

use std::fs::File;
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<()> {
        let mut file = File::create(path)?;
        for s in self.search(keyword) {
            file.write(s.as_bytes())?;
            file.write("\n".as_bytes())?;
        };
        Ok(())
    }
}

Mladen Rasic

mladen5000

2 months ago

4.77ms

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::Write;
        let mut f = File::create(path)?;
        let matches: Vec<_> = self.search(keyword);
        matches
            .into_iter()
            .map(|m| writeln!(f, "{}", m))
            .collect::<std::io::Result<()>>()
    }
}

Ferdinand de Baecque

Ferdinanddb

2 months ago

5.31ms

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