Lifetimes

Lifetimes in Rust ensure that references are valid for as long as they are needed. The Rust compiler uses lifetimes to prevent dangling references, ensuring memory safety at compile time without the need for a garbage collector.

A common scenario where lifetimes come into play is when working with functions that accept or return references. To ensure the correct association between input references and output references, lifetimes are explicitly annotated.

In this challenge, you'll implement a function that finds the longest string slice from two provided references. The function will use lifetimes to ensure that the returned reference is valid for as long as both input references are valid.

Your Task

Write a function longest that takes two string slices and returns the longest one. If both slices are of the same length, return the first one.

Hints

Click here to reveal hints

Use explicit lifetime annotations in the function signature, such as 'a. e.g

fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
    // implementation goes here
}

Rust allows you to compare the lengths of strings using the .chars().count() method.

Editor not available on Mobile!

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

Solutions

amaneru

7ma8no9

9 hours ago

4.51ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() >= s2.chars().count() {
        s1
    } else {
        s2
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Kentaro Abe

abekem

11 hours ago

3.91ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() >= s2.chars().count() {
        return s1;
    } else {
        return s2;
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Guilherme Cesário Strachan

strachan

a day ago

6.97ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() >= s2.chars().count() {
        return s1;
    }
    s2
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Sandeep chauhan

ryzen-xp

a day ago

4.78ms

89.26kb

pub fn longest<'a>(s1 : &'a str  , s2 : &'a str)-> &'a str{
    if s1.chars().count() >= s2.chars().count(){
        s1
    }
   
    else {
        s2
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Anıl Şenay

anilsenay

2 days ago

5.28ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() >= s2.chars().count() {
        return s1;
    }
    return s2;
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Romain Grimau

Herrgrim0

2 days ago

4.01ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() >= s2.chars().count() {
        s1
    } else {
        s2
    }
} // Finish the function
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

AKA.MoneyTaker

M4Bo2

3 days ago

4.76ms

89.26kb

pub fn longest // Finish the functionWrite a function longest that takes two string slices and returns the longest one. If both slices are of the same length, return the first one.
<'a>(s1:&'a str,s2:&'a str)->&'a str{
    if  s1.chars().count() >= s2.chars().count(){
        s1
    }else{s2}
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Dyaa Adel

dyaa-adel

6 days ago

5.90ms

89.26kb

pub fn longest<'a>(s1 : &'a str, s2: &'a str) -> &'a str {
    if (s1.chars().count() >= s2.chars().count()) {
        s1
    } else {
        s2
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

manuelmj

7 days ago

5.47ms

89.26kb

pub fn longest<'a>(first_str: &'a str , second_str: &'a str)-> &'a str{
    
    if first_str.chars().count() >= second_str.chars().count() {
        return first_str;
    } 
    second_str 
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Ayushman Rathore

Spartan09

9 days ago

5.38ms

89.26kb

pub fn longest<'a>(substr_one: &'a str, substr_two: &'a str) -> &'a str {
    match (substr_one, substr_two) {
        (a, b) if a.chars().count() >= b.chars().count() => a,
        (_, b) => b
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Jun Huang

leemars

10 days ago

4.70ms

89.26kb

pub fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
    if first.chars().count() >= second.chars().count() {
        first
    } else {
        second
    }
} // Finish the function
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

automata-studio

11 days ago

4.69ms

89.26kb

pub fn longest<'a>(slice1 :&'a str, slice2: &'a str) -> &'a str {
    if slice1.chars().count() >= slice2.chars().count() {
        slice1
    }
    else {
        slice2
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Jordan

Jordan-Haidee

12 days ago

4.24ms

89.26kb

pub fn longest<'a>(s1:&'a str, s2:&'a str) -> &'a str {
    if s1.chars().count() >= s2.chars().count() {
        s1 
    } else {
        s2
    }
} // Finish the function
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Kenneth Love

kennethlove

14 days ago

5.16ms

89.26kb

pub fn longest<'a>(one: &'a str, two: &'a str) -> &'a str {
    if one.chars().count() >= two.chars().count() { one } else { two }
} // Finish the function
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Algorab

14 days ago

4.20ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() >= s2.chars().count() {
        s1
    } else {
        s2
    }
}// Finish the function
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Marco-Normal

15 days ago

4.08ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() >= s2.chars().count() {
        return s1
    }
    s2
} // Finish the function
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

ludovicknecht

15 days ago

4.53ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    match s1.chars().count() >= s2.chars().count() {
        true => &s1,
        false => &s2,
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

ludovicknecht

15 days ago

24.22ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    match s1.chars().count() >= s2.chars().count() {
        true => &s1,
        false => &s2,
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Muhammad-Dennis

16 days ago

4.49ms

89.26kb

pub fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    let a_len = a.chars().count();
    let b_len = b.chars().count();
    if a_len > b_len || a_len == b_len {
        return a
    } else {
        return b
    }
} // Finish the function
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

alemack17

16 days ago

3.73ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str)->&'a str{
    if s1.chars().count()>=s2.chars().count(){
        s1
    }else{
        s2
    }
} // Finish the function
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Denis SOURON

Brack0

16 days ago

5.38ms

89.26kb

use std::cmp::Ordering;
pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    match s1.chars().count().cmp(&s2.chars().count()) {
        Ordering::Greater | Ordering::Equal => s1,
        Ordering::Less => s2,
    }
}

Christopher Nielson

c-nielson

16 days ago

5.57ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() > s2.chars().count() || s1.chars().count() == s2.chars().count(){
        s1
    } else {
        s2
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

iamforgettable

18 days ago

4.07ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() >= s2.chars().count() {
        s1
    } else {
        s2
    }
} // Finish the function
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

rawar089

19 days ago

4.33ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if  s1.chars().count() < s2.chars().count() {
        s2
    } else {
        s1
    }
} 
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

kosay

sarub0b0

19 days ago

4.66ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    match s1.chars().count().cmp(&s2.chars().count()) {
        std::cmp::Ordering::Less => s2,
        std::cmp::Ordering::Greater => s1,
        std::cmp::Ordering::Equal => s1,
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

delxs

19 days ago

5.35ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2:&'a str) -> &'a str// Finish the function
{
    if s1.chars().count() >= s2.chars().count() {
        return s1;
    } else  {
        return s2;
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Nikita Smirnov

Nismirno

21 days ago

4.63ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    let size1 = s1.chars().count();
    let size2 = s2.chars().count();
    if size1 < size2 {
        s2
    } else {
        s1
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Elliott Draper

ejdraper

21 days ago

4.65ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() < s2.chars().count() {
        return s2;
    } else {
        return s1;
    }
} // Finish the function
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Oebelus

oebelus

22 days ago

4.21ms

89.26kb

pub fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.chars().count() >= y.chars().count() {
        x
    } else {
        y
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Justin Maillet

justy777

23 days ago

5.28ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() >= s2.chars().count() {s1} else {s2}
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Jim Lawton

jimlawton

23 days ago

4.41ms

89.26kb

pub fn longest<'a>(string1: &'a str, string2: &'a str) -> &'a str {
    if string1.chars().count() > string2.chars().count() {
        string1
    } else if string1.chars().count() < string2.chars().count() {
        string2
    } else {
        string1
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Shafer Hess

shafer-hess

24 days ago

4.00ms

89.26kb

pub fn longest<'a>(str1: &'a str, str2: &'a str) -> &'a str{
    if str1.chars().count() >= str2.chars().count() {
        str1
    } else {
        str2
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Stefan Roas

sroas

24 days ago

5.80ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    match s1.chars().count().cmp(&s2.chars().count()) {
        std::cmp::Ordering::Less => s2,
        _ => s1,
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

Jonathan Voss

jvoss

25 days ago

4.57ms

89.26kb

use std::cmp::Ordering;
pub fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    match x.chars().count().cmp(&y.chars().count()) {
        Ordering::Less => { &y },
        _ => { &x }
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

TaiPoole

a month ago

7.60ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() >= s2.chars().count() {
        s1
    } else {
        s2
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

dawwestk

a month ago

4.80ms

89.26kb

pub fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
    if first.chars().count() >= second.chars().count() {
        first
    } else {
        second
    }
}  // Finish the function
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}

PangoSea

kapaseker

a month ago

6.17ms

89.26kb

pub fn longest<'a>(a:&'a str, b:&'a str) -> &'a str {
    if a.chars().count() < b.chars().count() {
        b
    } else {
        a
    }
}
// Example usage
pub fn main() {
    let s1 = "short";
    let s2 = "longer string";
    let result = longest(s1, s2);
    println!("The longest string is: {}", result);
    assert_eq!(result, "longer string");
    let s3 = "equal";
    let s4 = "equal";
    let result = longest(s3, s4);
    println!("The longest string is: {}", result);
    assert_eq!(result, "equal");
}