Day 7 The Great Log Hunt

The tension in the North Pole Dev room had not dissipated. Santa’s absence loomed large, and Blitzen had clearly let the power go to his antlers. The elves were beginning to mutter about mutiny—especially after Blitzen had loudly declared that grep was overrated and "real devs" write their own search tools.

“We need a better log system,” Blitzen announced, pacing in front of the DevOps board like a caffeinated startup founder. “I’m tired of manually combing through logs! It’s time we automate this.”

Prancer peeked up from their desk. “Can’t we just pipe the logs into grep like everyone else?”

Blitzen’s glare could have melted the polar ice caps. “Prancer, if you’re going to suggest mediocre solutions, you can go back to working in Node.js.”

Prancer recoiled, whispering, “Too far, Blitzen. Too far.”

A LogQuery Tool

Blitzen wanted a log search tool so advanced that even Santa would call it “blitzening fast.” Logs were piling up from every North Pole subsystem—Toy Tracker 3000, SleighOS, and even Reindeer AI. The elves needed to find specific entries without scrolling for hours.

“You!” Blitzen pointed at Frostbyte, the elf known for typing faster than a Model M keyboard. “You’re going to write a LogQuery struct in Rust that can search through our logs.”

Frostbyte cracked his knuckles, opened NeoVim, and got to work.

But he needs your help to be saved from Blitzen’s sass and implement the LogQuery struct with its search method?

The Requirements:

Here’s what Frostbyte must implement:

LogQuery struct: This struct should hold a reference to a slice of String logs.
new() Create an associated function named new that accepts a reference to a Vec<String> and returns a LogQuery.
Search method: A method named search that:
1. Returns a Vec of references to strings containing the keyword.
2. Should work even if the logs are empty.
3. Special characters in the keyword must be handled properly.

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.

Your LogQuery struct will likely hold a &'a Vec<String>.

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}

The new function should accept a reference to a &'a Vec<String> and return a LogQuery.
The search method should accept a &self and a keyword: &str parameter.
To return references to the logs, you can use -> Vec<&'a String>
Implement search by iterating over self.logs. e.g. self.logs.iter()
Use filter and provide a closure. e.g. filter(|log| {})
Use contains to check if a log contains the keyword. e.g. log.contains(keyword)
Use collect to convert the iterator back to a Vec. e.g. collect::<Vec<_>>()

Editor not available on Mobile!

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

Solutions

sam

nextbysam

a day ago

3.62ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a>{
    pub fn new(logs: &'a Vec<String>) -> LogQuery<'a>{
        LogQuery { logs }
    }
    pub fn search(&self, keywords : &str) -> Vec<&'a str> {
        self.logs
            .iter()
            .filter(|log| log.contains(keywords))
            .map(|log| log.as_str())
            .collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

PierreBhs

2 days ago

3.52ms

88.09kb

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
//
// 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 new(logs: &'a Vec<String>) -> Self {
        LogQuery {logs}
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs.iter().filter(|s| s.contains(keyword)).collect()
    }
}

Dave Weston

dtweston

4 days ago

3.75ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> LogQuery {
        Self { logs }
    }
    pub fn search(&self, query: &str) -> Vec<&str> {
        let mut results: Vec<&str> = Vec::new();
        for log in self.logs {
            if log.contains(query) {
                results.push(log);
            }
        }
        
        results
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

Asrul Firdaus

AsrulF

5 days ago

4.06ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery {
            logs,
        }
    }
    pub fn search(&self, keyword: &'a str) -> Vec<&'a str> {
        if !keyword.is_ascii() {
            println!("Please input correct word");
        }
        let mut result = Vec::<&str>::new();
        for log in self.logs {
            if log.contains(keyword) {
                result.push(log);
            }
        }
        result
    } 
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

Ivan Bykov

renbrek

6 days ago

4.35ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery {logs}
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        let mut result: Vec<&String> = vec![];
        
        for log in self.logs {
            if log.contains(keyword) {
                result.push(&log)
            } 
        }
        result
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

Felix Paetow

hoall

6 days ago

3.60ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(given: &'a Vec<String>) -> Self{
        LogQuery{
            logs : given,
        }
    }
    pub fn search(&self, text: &str) -> Vec<&String> {
        self.logs.iter().filter(|log| log.contains(text)).collect()
    }
}

Ramon Silva

rsilva1

7 days ago

3.85ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery {
            logs
        }
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.
impl <'a> LogQuery<'a> {
    pub fn search(&self, pat: &str) -> Vec<&'a String> {
        self.logs.iter().filter(|log| log.contains(pat)).collect()
    }
}

nurs

8 days ago

3.59ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self { logs }
    }
    pub fn search(&self, word: &str) -> Vec<&String> {
        self.logs.iter().filter(|log| log.contains(word)).collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

Anthony Young

A-Young-Git

10 days ago

4.14ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self {
            logs: logs,
        }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        let results = self.logs.iter().filter(|log| { log.contains(keyword) }).collect::<Vec<_>>();
        return results
    }
}

nx0ly

12 days ago

3.58ms

88.09kb

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, query: &str) -> Vec<&'a String> {
        let a: Vec<&String> = self.logs.iter().filter(|x| x.contains(query)).collect();
        a
    }
}

yuvicc

16 days ago

8.31ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery { logs }
    }
    pub fn search(&self, query: &str) -> Vec<&'a String> {
        let mut results = Vec::new();
        for log in self.logs.iter() {
            if log.contains(query) {
                results.push(log);
            }
        }
    results
    }
}

Pieter-Jan van Dam

pjvandam

16 days ago

3.56ms

88.09kb

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(reference: &'a Vec<String>) -> Self {
        Self{
            logs: reference
        }
    }
// 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)) // predicate returns bool
            .collect()
    }
}

Pieter-Jan van Dam

pjvandam

16 days ago

3.65ms

88.09kb

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(reference: &'a Vec<String>) -> Self {
        Self{
            logs: reference
        }
    }
// 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)) // predicate returns bool
            .collect()
    }
}

Chawin Chaisongkram

chawinkn

17 days ago

3.39ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

Octave

BadyJoke

19 days ago

3.48ms

88.09kb

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

luke-nigro

20 days ago

3.73ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> LogQuery {
        LogQuery{
            logs: logs
        }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| {log.contains(keyword)})
            .collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

Nguyen Ky Tri

tringuyenarup

20 days ago

4.04ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery <'a>{
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self{logs}
    }
    pub fn search(&self, keyword: &str) -> Vec<&String> {
        self.logs
            .iter()
            .filter(|entry| entry.contains(keyword))
            .collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

Daffa Karyudi

KeyCode17

22 days ago

3.42ms

88.09kb

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

Daffa Karyudi

KeyCode17

22 days ago

4.17ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a>{
    pub fn new(logs: &'a Vec<String>)->Self{
        Self{
            logs
        }
    }
    pub fn search(&self, keyword:&str)-> Vec<&'a String> {
        self.logs
        .iter()
        .filter(|log| log.contains(keyword))
        .collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

LiveForLife

maplestarplayl

22 days ago

4.78ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self {logs}
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a str> {
        let mut res = Vec::new();
        if self.logs.is_empty() {
            return res;
        }
        for log in self.logs {
            if log.contains(keyword) {
                res.push(log);
            }
        }
        
        res
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

Dylan Crees

drcrees

23 days ago

5.02ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self { 
        Self {
            logs
        }
    } 
    pub fn search(&self, keyword: &str) -> Vec<&String> {
        let mut logs = vec![];
        for i in 0..self.logs.len() {
            if self.logs[i].contains(keyword) {
                logs.push(&self.logs[i]); 
            }
        }
        logs
    }
}

Volodymyr Koreniev

vkorenev

23 days ago

5.09ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> LogQuery {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&str> {
        self.logs.into_iter().map(String::as_str).filter(|s| s.contains(keyword)).collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

blackdeath1346

24 days ago

5.41ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a>
{
    pub fn new(logs: &'a Vec<String>)->LogQuery<'a>
    {
        return LogQuery{logs: logs};
    }
    pub fn search(&'a self, keyword: &'a str)->Vec<& 'a str>
    {
        let mut ans: Vec<& str>=Vec::new();
        for entry in self.logs
        {
            if entry.contains(keyword)
            {ans.push(entry);}
        }
        return ans;
    }
}
// 1. Finish the implementation of LogQuery
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

petrokropyvatablet-dotcom

a month ago

4.77ms

88.09kb

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 {
        Self {
            logs
        }
    }
//
// 3. Create a public method named `search` that accepts a string slice and finds it from the logs and
    pub fn search (&self, keyword: &str) -> Vec<&'a String> {
        let result = self.logs.iter().filter(|log| {log.contains(keyword)});
        //    returns a vector of references to those logs.
        result.collect::<Vec<_>>()
    }
}

StevenCanDrink

a month ago

5.59ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(i: &'a Vec<String>) -> Self {
        Self {
            logs: i,
        }
    }
    pub fn search(self, i: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|item| item.contains(i))
            .collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

jfloresremar

a month ago

4.29ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
}

Erik Zhao

zhaoerik

a month ago

4.81ms

88.09kb

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 {
        Self{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, search_term: &str) -> Vec<&String> {
        let mut result = Vec::new();
        for val in self.logs {
            if val.contains(search_term) {
                result.push(val);
            }
        }
        return result;
    }
}

Alex Conley

aconley

2 months ago

4.90ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        LogQuery{ logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&String> {
        let mut result = Vec::new();
        for val in self.logs {
            if val.contains(keyword) {
                result.push(val);
            }
        }
        result
    }
}

msned

2 months ago

4.39ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a>{
    pub fn new(logs : &'a Vec<String>)->LogQuery<'a>{
        Self{logs}
    }
    pub fn search(&self, keyword : &str)->Vec<&'a String>{
        self.logs.into_iter().filter(|n| n.contains(keyword)).collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

asdf

nitipot

2 months ago

4.93ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self{logs}
    }
    pub fn search(&self, keyword : &str) -> Vec<&'a String> {
        self.logs.iter().filter(|log| log.contains(keyword)).collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

TheJanzap

2 months ago

8.92ms

88.09kb

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 {
        Self { 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<&String> {
        self.logs
            .iter()
            .filter(|l| l.contains(keyword))
            .collect::<Vec<_>>()
    }
}

Emre Erbekin

erbekin

2 months ago

3.62ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs : &'a Vec<String>) -> Self {
        Self {
            logs
        }
    }
    pub fn search(&self, keyword : &str) -> Vec<&'a str> {
        self.logs.iter().filter(|log| log.contains(keyword)).map(|s| s.as_str()).collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

rap1 ラピ

srcrapi

2 months ago

3.42ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self {
            logs 
        }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

GavFred

2 months ago

3.68ms

88.09kb

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(strings: &'a Vec<String>) -> Self {
        LogQuery { logs: strings }
    }
//
// 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<&String> {
        self.logs.iter().filter(|l| {
            l.contains(keyword)
        }).collect()
    }
}

Smith, Taylor

a647965_fidelity

2 months ago

3.96ms

88.09kb

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 {
        Self { 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<'b>(&'a self, keyword: &'b str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
}

Keegan Conlee

dacid44

2 months ago

4.87ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self { logs }
    }
    pub fn search(&self, query: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| log.contains(query))
            .collect()
    }
}

Andrea Zoleo

andrea-zoleo

2 months ago

3.56ms

88.09kb

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>) -> LogQuery<'a> {
        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, s: &str) -> Vec<&'a String> {
        self.logs.iter().filter(|ss| ss.contains(s)).collect()     
    }
}

kartik adur

kartikadur

2 months ago

3.68ms

88.09kb

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::<Vec<&'a String>>()
    }
}

Sebastien Vassal

svassal

2 months ago

3.47ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> LogQuery<'a> {
        LogQuery { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        if self.logs.len() == 0 {
            return Vec::new();
        }
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
}

jovanoviccn

2 months ago

3.49ms

88.29kb

pub struct LogQuery<'a>{
    logs:Vec<&'a str>
}
impl<'a> LogQuery<'a> {
    pub fn new(vec:&'a Vec<String>) -> LogQuery<'a> {
        let logs=vec.iter().map(|x| x.as_str()).collect();    
        LogQuery { logs: logs }
    }
    pub fn search(&self, keyword:&str)->Vec<&'a str>{
        let new =self.logs.iter().filter(|s|s.contains(keyword)).map(|s|*s).collect();
        new
    }
}

Prashant Puri

Prashant-dot1

3 months ago

4.17ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self {
            logs
        }
    }
    pub fn search(&self, keyword: &'a str) -> Vec<&'a String> {
        self.logs.iter().filter(|log| {
            log.contains(keyword)
        }).collect::<Vec<&'a String>>()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

Heino Mortensen

hmortensen83

3 months ago

4.49ms

88.09kb

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 {
        Self { 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(|line| line.contains(keyword))
            .collect::<Vec<_>>()
    }
}

Spheniscine

3 months ago

3.81ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs.iter().filter(|&log| log.contains(keyword)).collect()
    }
}

Andreas Lundin

andreaslundin47

3 months ago

6.29ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self { logs }
    }
    pub fn search(self: &Self, keyword: &str) -> Vec<&String> {
        self.logs.iter().filter(|log| log.contains(keyword)).collect()
    }
}

Andreas Lundin

andreaslundin47

3 months ago

4.92ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self { logs }
    }
    pub fn search(self: &Self, keyword: &str) -> Vec<&String> {
        self.logs.iter().filter_map(|log| {
            if log.contains(keyword) { 
                Some(log) 
            } else { 
                None 
            }
        }).collect()
    }
}

visanr

3 months ago

3.78ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&String> {
        self.logs.iter().filter(|log| log.contains(keyword)).collect()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

palcoo42

3 months ago

4.11ms

88.09kb

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

angalar

3 months ago

3.67ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self {logs}
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        self.logs
            .iter()
            .filter(|log| {log.contains(keyword)})
            .collect()
    }
}

Khant

Khantdotcom

3 months ago

4.36ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl <'a> LogQuery<'a>{
    pub fn new(vec : &'a Vec<String>) -> LogQuery{
        LogQuery {
            logs: vec
        }
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String>{
        self.logs
            .iter()
            .filter(|log| {log.contains(keyword)})
            .collect::<Vec<_>>()
    }
}
// 2. Create a public associated function named `new()` that will take a reference to a vector of strings
//
// 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.

johndoe30bc

3 months ago

3.55ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
    pub fn new(logs: &'a Vec<String>) -> Self {
        Self { logs }
    }
    pub fn search(&self, keyword: &str) -> Vec<&String> {
        self.logs.iter().filter(|x| x.contains(keyword)).collect()
    } 
}