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

StevenCanDrink

5 days ago

4.56ms

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");
}

amdfxlucas

5 days ago

4.43ms

89.26kb

pub fn longest<'u>(a: &'u str, b: &'u str) -> &'u str {
    if a.chars().count() >= b.chars().count()
    {
        return a
    }else {
        return 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");
}

Chih Ying Yen

xavierforge

8 days ago

4.10ms

89.26kb

pub fn longest<'a>(lhs: &'a str, rhs: &'a str) -> &'a str {
    if lhs.chars().count() >= rhs.chars().count() {
        lhs
    } else {
        rhs
    }
}
// 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");
}

undefeated_

boyboi86

9 days ago

4.04ms

89.26kb

pub fn longest<'a>(input1: &'a str, input2: &'a str) -> &'a str {
    if input1.chars().count() < input2.chars().count() {
        input2
    } else {
        input1
    }
} // 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");
}

shahab-tplus

12 days ago

5.15ms

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");
}

toto

12 days ago

4.55ms

89.26kb

pub fn longest<'a>(slice1: &'a str, slice2: &'a str) -> &'a str {
    // Finish the function
    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");
}

GunGraveCpp

12 days ago

5.49ms

89.26kb


pub fn longest<'a>(f_v: &'a str, s_v: &'a str ) -> &'a str {
    if f_v.chars().count() >= s_v.chars().count() {
        return f_v;
    } else {
        return s_v;
    }
}
// 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");
}

manu3618

14 days ago

5.77ms

89.26kb

pub fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { // Finish the function
    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");
}

Lvfalue

15 days ago

4.70ms

89.26kb

pub fn longest<'a>(left: &'a str, right: &'a str) -> &'a str {
    if left.chars().count() >= right.chars().count() {
        left
    } else {
        right
    }
} // 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");
}

Jean-baptiste JOFFRE

Indy79

16 days ago

4.19ms

89.26kb

pub fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
    if first.chars().count() >= second.chars().count() {
        return first
    }
    second
}
// 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");
}

visanr

17 days ago

4.84ms

89.26kb

pub fn longest<'a>(lhs: &'a str, rhs: &'a str) -> &'a str {
    if lhs.chars().count() >= rhs.chars().count() {
        return lhs;
    }
    rhs
} // 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");
}

aghia98

20 days ago

5.99ms

89.26kb

pub fn longest<'a>(slice1: &'a str, slice2: &'a str) -> &'a str {
    if slice1.chars().count() < slice2.chars().count() {
        slice2
    } else if slice1.chars().count() > slice2.chars().count(){
        slice1
    } else {
        slice1
    }
} // 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");
}

Luka Bračun

lbracun

23 days ago

5.70ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
  if s2.chars().count() > s1.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");
}

bzdula

23 days ago

4.93ms

89.26kb

pub fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
    if first.chars().count() >= second.chars().count() {
        first
    } else {
        second
    }
}
// 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");
}

Ranjith Thangavel

RanjithECE24

23 days ago

5.31ms

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");
}

Wouter

WouterMartens

a month ago

4.18ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.chars().count() >= s2.chars().count() {
        s1
    } else {
        s2
    }
}
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");
}

Daniel Mestas

miel-codeai

a month ago

4.70ms

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");
}

Andy Randrianirina

andyslash

a month ago

4.55ms

89.26kb

pub fn longest<'life>(first: &'life str, second: &'life str) -> &'life 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");
}

Rocky.C

cloki0610

a month ago

3.92ms

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");
}

m1031

monorail103

a month ago

4.13ms

89.26kb

pub fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
    if first.chars().count() >= second.chars().count() {
        return first;
    }
    second
}
// 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");
}

slaws

a month ago

4.24ms

89.26kb

pub fn longest<'a> (s1: &'a str, s2: &'a str) -> &'a str { // Finish the function
    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");
}

Fatih

0fatih

a month ago

4.26ms

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");
}

Evrins Hu

evrins

a month ago

4.18ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2 : &'a str) -> &'a str {
    let n1 = s1.chars().count();
    let n2 = s2.chars().count();
    if n1 >= n2 {
        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");
}

Baron Curtin

baroncurtin2

a month ago

4.27ms

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");
}

johndoe30bc

a month ago

6.54ms

89.26kb

pub fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.chars().count() >= b.chars().count() {
        a
    } else {
        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");
}

AtlasVakyrie

a month ago

6.46ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    let s1_len = s1.chars().count();
    let s2_len = s2.chars().count();
    if s1_len >= s2_len {
        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");
}

xxxxsk

a month ago

3.88ms

89.26kb

pub fn longest<'a>(a: &'a str, b: &'a str) -> &'a str { // Finish the function
    if a.chars().count() >= b.chars().count() {
        a
    } else {
        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");
}

bernardoLY19

a month ago

4.39ms

89.26kb

pub fn longest<'a>(a: &'a str, b: &'a str) -> &'a str{
    if a.chars().count() < b.chars().count(){
        return b
    }else {
        return 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");
}

Evgenii Grigorenko

grevgeny

a month ago

4.79ms

89.26kb

use std::cmp::Ordering;
pub fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    let a_charlen = a.chars().count();
    let b_charlen = b.chars().count();
    match a_charlen.cmp(&b_charlen) {
        Ordering::Equal | Ordering::Greater => a,
        Ordering::Less => 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");
}

FredoPo

2 months ago

5.74ms

89.26kb

// Finish the function
pub fn longest<'a>(word1: &'a str, word2: &'a str) -> &'a str {
    if word1.chars().count() >= word2.chars().count() {
        return word1;
    }
    word2
}
// 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");
}

Procybit

2 months ago

4.42ms

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");
}

brucecox01

2 months ago

4.36ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str { // Finish the function
    if s2.chars().count() > s1.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");
}

Miguel Ángel Allende

maallende

2 months ago

5.12ms

89.26kb


pub fn longest<'a>(value1: &'a str, value2: &'a str) -> &'a str {
    if value1.chars().count() >= value2.chars().count() {
        value1
    } else {
        value2
    }
}
// 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");
}

Krzysztof Atłasik

katlasik

2 months ago

4.27ms

89.26kb

pub fn longest<'a>(lhs: &'a str, rhs: &'a str) -> &'a str {
    if lhs.chars().count() >= rhs.chars().count() {
        lhs
    } else {
        rhs
    }
}
// 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");
}

coreyralph

2 months ago

4.13ms

89.26kb

pub fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.chars().count() >= b.chars().count() {
        a
    } else {
        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");
}

medzernik

2 months ago

4.05ms

89.26kb

pub fn longest<'a>(string_1: &'a str, string_2: &'a str) -> &'a str {
    if string_1.chars().count() >= string_2.chars().count() {
        string_1
    } else {
        string_2
    }
}
// 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");
}

Artem Nistuley

artemnistuley

2 months ago

3.74ms

89.26kb

pub fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
    let c1 = first.chars().count();
    let c2 = second.chars().count();
    if c1 >= c2 { 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");
}

Philippe Massicotte

PMassicotte

2 months ago

4.09ms

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");
}

gsspdev

2 months ago

4.23ms

89.26kb

// Finish the function
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");
}

Herman effendi

hrmneffdii

2 months ago

4.35ms

89.26kb

pub fn longest<'a>(input1: &'a str, input2: &'a str) -> &'a str {
    if input2.chars().count() > input1.chars().count() {
        return input2;
    } else {
        return input1;
    }
}
// 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");
}

esl

esl07

2 months ago

4.25ms

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");
}

esl

esl07

2 months ago

4.43ms

89.26kb

pub fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    let s1_len = s1.chars().count();
    let s2_len = s2.chars().count();
    if s1_len >= s2_len {
        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");
}

Ushakov Andrey

stdstring

2 months ago

4.01ms

89.26kb

pub fn longest<'a>(first: &'a str, second: &'a str) -> &'a str {
    if first.chars().count() >= second.chars().count() {
        first
    } else {
        second
    }
}
// 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");
}

alexsavio

2 months ago

3.98ms

89.26kb

pub fn longest<'a>(input1: &'a str, input2: &'a str) -> &'a str {
    if input2.chars().count() > input1.chars().count() {
        return input2;
    } else {
        return input1;
    }
}
// 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");
}

vanos001

2 months ago

4.09ms

89.26kb

pub fn longest<'t>(a:&'t str,b:&'t str) -> &'t str{
    return if a.chars().count() >= b.chars().count() {
        a
    }else{
        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");
}

Tengz Mao

MaoX-Yu

2 months ago

4.30ms

89.26kb

pub fn longest<'a>(a: &'a str, b: &'a str) -> &'a str { // Finish the function
    if a.chars().count() >= b.chars().count() {
        a
    } else {
        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");
}

Kr0wZ

2 months ago

6.24ms

89.26kb

pub fn longest<'a>(str1: &'a str, str2: &'a str) -> &'a str {
    if str1.chars().count() > str2.chars().count() {
        return str1;
    } else {
        if str1.chars().count() < str2.chars().count() {
            return str2;
        }
    }
    str1
}
// 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");
}

0x0f1

Paul4673

2 months ago

4.02ms

89.26kb

pub fn longest<'a>(a : &'a str, b: &'a str) -> &'a str {
    if a.chars().count() < b.chars().count() {
        return b
    } {
        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");
}

Enes

enesscevik

2 months ago

5.37ms

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");
}

Holger Knauer

hknauer

2 months ago

4.64ms

89.26kb

pub fn longest<'a>(a: &'a str, b:&'a str) -> &'a str  { // Finish the function
    if a.chars().count() >= b.chars().count() {
        a
    }  else {
        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");
}