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

Kishan Patel

KishanPatel4273

2 days ago

5.79ms

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> {
        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, query: &str) -> Vec<&String> {
        let mut res = Vec::<&String>::new();
        
        for log in self.logs {
            if log.contains(query) {
                res.push(log);
            }
        }
        res
    }
}

FredoPo

4 days ago

3.90ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'_> {
// 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, keyword: &str) -> Vec<&String> {
        self.logs.iter().filter(|log| {
            log.contains(keyword)
        }).collect::<Vec<_>>()
    }
}

SilentCanon

silentcanon

6 days ago

4.58ms

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: 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 str> {
        let mut result: Vec<&str> = Vec::new();
        for log in self.logs.iter() {
            if log.contains(keyword) {
                result.push(log);
            }
        }
        result
    }
}

anjanimaurya

8 days ago

34.29ms

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: &'a str)->Vec<&String>{
        let mut found:Vec<&String> = Vec::new();
                  
        for log_entry in self.logs.iter(){
            if log_entry.contains(keyword){
                found.push(log_entry);     
            }
        }
        found        
    }
}
//

Christopher Nielson

c-nielson

10 days ago

4.79ms

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

Yi Hao

leongyihao

10 days ago

3.54ms

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 found = Vec::<&String>::new();
		self.logs.iter().for_each(|item| {
			if item.contains(keyword) {
				found.push(item);
			}
		});
		found
	}
}

rponcepore

10 days ago

4.12ms

88.09kb

pub struct LogQuery<'a> {
  logs: &'a Vec<String>,
}
impl<'a> LogQuery<'a> {
  pub fn new(strings: &Vec<String>) -> LogQuery {
    LogQuery{
      logs: strings,
    }
  }
  pub fn search(&self, target: &str) -> Vec<&String> {
    let mut result = Vec::new();
    for log in self.logs {
      if log.contains(target) {
        result.push(log);
      }
    }
    result
  }
}

avilikof

13 days ago

3.62ms

88.09kb

// Write a function that returns the reference to the longer string
// without any new allocations
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>) -> LogQuery<'a> {
        LogQuery {logs}
    }
    pub fn search(&self, query: &str) -> Vec<&String> {
        self.logs.iter().filter(|log| log.contains(query)).collect()
    }
}

DjozH

14 days ago

3.32ms

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(x: &'a Vec<String>) -> Self {
        LogQuery {logs: x}
    }
// 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>>()
    }
}

codervijo

24 days ago

4.15ms

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

Leandro Abreu

leandronowras

25 days ago

4.20ms

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

Chess Luo

chessl

a month ago

3.72ms

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, keyword: &str) -> Vec<&str> {
        self.logs
            .iter()
            .filter(|l| l.contains(keyword))
            .map(|l| l.as_str())
            .collect()
    }
}

zitro

0zitro

a month ago

10.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
    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(|s| s.contains(keyword)).collect()
    }
}

Alex Ioannidis

slint

a month ago

6.84ms

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

Erik Werner

rikner

a month ago

3.98ms

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

William Chu

uptickmetachu

a month ago

4.40ms

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> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect()
    }
}

adli daffa

addffa

a month ago

3.70ms

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> {
        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.

aey4

a month ago

3.80ms

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

Hideyuki Tanaka

tanakh

a month ago

31.74ms

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

ainem

ainem-m

a month ago

4.73ms

88.09kb

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

Stefan Toman

stoman

a month ago

4.86ms

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: 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, query: &str) -> Vec<&String> {
        let mut ret:Vec<&String>  = Vec::new();
        for s in self.logs {
            if s.contains(query) {
                ret.push(&s);
            }
        }
        ret
    }
}

Stefan Toman

stoman

a month ago

4.70ms

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: 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, query: &'a str) -> Vec<&String> {
        let mut ret:Vec<&String>  = Vec::new();
        for s in self.logs {
            if s.contains(query) {
                ret.push(&s);
            }
        }
        ret
    }
}

viky

vikyw89

a month ago

4.65ms

88.09kb

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

KamiTrades

kamixbt

a month ago

3.53ms

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, kword: &str) -> Vec<&String>{
        self.logs.iter().filter(|log| log.contains(kword)).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.

Zeel Darji

zeel991

a month ago

3.99ms

88.09kb

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

Jonathan

tato123

a month ago

4.41ms

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

Romain Perier

rperier

a month ago

3.76ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new (input: &'a Vec<String>) -> Self {
        Self { logs: input }
    }
    pub fn search(&self, keyword: &str) -> Vec<&String> {
        self.logs.iter()
            .filter(|e| e.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.

Y.

klllr

a month 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 (v: &'a Vec<String>) -> Self {
        Self { logs: v }
    }
    pub fn search (&self, word: &str) -> Vec<&'a String> {
        self.logs.iter().filter(|s| s.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.

Peter Schols

pschols

a month ago

4.61ms

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, query: &str) -> Vec<&String> {
        self.logs.iter().filter(|log| log.contains(query)).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.

Bambalam

bambalamm

a month ago

3.72ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
// 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(raw_logs: &Vec<String>) -> LogQuery {
        let logs = raw_logs;
        return 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> {
        return self
            .logs
            .iter()
            .filter(|log| log.contains(keyword))
            .collect::<Vec<_>>();
    }
}

Bob Schmertz

rschmertz

a month ago

3.86ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl <'a>LogQuery<'a> {
    pub fn new<'b>(result: &'b Vec<String>) -> LogQuery<'b> {
        LogQuery {
            logs: result
        }
    }
    pub fn search<'c>(self, needle: &str) -> Vec<&'a String> {
        let mut result: Vec<&String> = Vec::new();
        for x in self.logs {
            if x.contains(needle) {
                result.push(x)
            }
        };
        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.

Juniper

user32121

a month ago

3.75ms

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 {
        return 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> {
        return self.logs.iter().filter(|log|log.contains(keyword)).collect();
    }
}

bryantcutler

a month 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(strings: &'a Vec<String>) -> Self {
        LogQuery{ logs: strings }
    }
    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.

Ryan Plauche

plauche

a month ago

4.30ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(data: &'a Vec<String>) -> LogQuery {
        LogQuery {
            logs: data
        }
    }
    pub fn search(&self, keyword: &str) -> Vec<&str> {
        self.logs.iter()
            .filter(|s| s.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.

Antoine Plard

tylp

a month ago

3.50ms

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.as_str().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.

Sergei Chertkov

mamont

a month ago

4.07ms

88.09kb

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

Hendrik Jennen

hendriko373

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

Helene Semb

HelenSem723

a month ago

3.95ms

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: logs
        }
    }
    pub fn search(&self, keyword: &str) -> Vec<&String>{
        self.logs.iter().filter(
            |t| t.find(keyword) != None
        ).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.

resty-daze

a month ago

3.61ms

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: logs}
    }
    pub fn search(self: Self, keywords: &str) -> Vec<&'a String> {
        self.logs.iter().filter(
            |t| t.find(keywords) != None
        ).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.

Benry Bytes

benrybytes

a month ago

3.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: &Vec<String>) -> LogQuery {
        LogQuery {
            logs
        }
    }
    pub fn search(&self, keyword: &str) -> Vec<&String> {
        self.logs.iter().filter_map(|x| {
            if x.contains(keyword) {
                return Some(x);
            }
            None
        }).collect::<Vec<&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.

acesolucoes

a month ago

3.58ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a> {
    pub fn new(vecString: &'a Vec<String>) -> LogQuery<'a> {
        return LogQuery{logs: vecString};
    }
    pub fn search(&self, keyword: &str) -> Vec<&'a String> {
        let mut vecString = vec![];
        for log in self.logs.iter() {
            if log.contains(keyword) {
                vecString.push(log)
            }
        }
        return vecString
    }
}
// 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.

Job Matheka

jobm

a month ago

3.29ms

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 str> {
        self.logs
            .iter()
            .filter(|log| log.contains(keyword))
            .map(|log| log.as_str())
            .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.

Pumkko

a month ago

3.57ms

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, term: &str) -> Vec<&String> {
        let logs = self.logs.iter().filter(|l| l.contains(term)).collect();
        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.

Omar Saber Talaat Abdelrahman

omar-s-ta

a month ago

5.47ms

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

João Paiva

jgpaiva

a month ago

3.60ms

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, q: &str) -> Vec<&String> {
        let mut retval = Vec::new();
        for s in self.logs {
            if s.contains(q) {
                retval.push(s);
            }
        }
        retval
    }
}
// 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.

mliertzer

a month ago

3.66ms

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

isaaclv

a month ago

3.57ms

88.09kb

pub struct LogQuery<'a> {
    logs: &'a Vec<String>,
}
// 1. Finish the implementation of LogQuery
impl<'a> LogQuery<'a>{
    pub fn new(input: &'a Vec<String>) -> Self {
        Self { logs: input }
    }
    pub fn search(&self, key: &str) -> Vec<&String> {
        self.logs.iter().filter(|log| log.contains(key)).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.

Waldo

whereswald0

a month ago

5.83ms

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 {
        LogQuery {
            logs: 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, slice: &str) -> Vec<&str> {
        let mut found: Vec<&str> = Vec::new();
        for log in self.logs {
            if log.as_str().contains(slice) {
                found.push(log);
            }
        }
        return found;
    }
}

Yossa Bourne

terminox

a month ago

3.36ms

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, slice: &str) -> Vec<&str> {
        let mut found: Vec<&str> = Vec::new();
        for log in self.logs {
            if log.as_str().contains(slice) {
                found.push(log);
            }
        }
        return found;
    }
}
// 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.

Mingzhe Yang

mei28

2 months ago

5.60ms

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