Day 6: Blitzen and Snowball’s Unproductive Debate

The North Pole Dev room was quiet—too quiet. Santa was still away and Blitzen was still in charge for the day, the elves didn't like that, some wished Santa's unhinged management style was back.

Blitzen leaned back in his reindeer chair knowing he's the boss now, sipping his coffee. “Hey, Snowball, did you know a function in Rust can return a reference?”

Snowball was a junior developer, he didn't know anything about Rust especially references, it seemed to confuse him, he looked up from their keyboard, skeptical. “That’s absurd. Functions return values, not references. You can’t return a borrowed value, Blitzen. It’ll dangle.”

“Oh, you poor, naive elf,” Blitzen said with a smug grin. “Behold the power of lifetimes!” He started scribbling on the whiteboard.

“Okay, but why do we even need this?” Snowball asked, raising an eyebrow. “What’s the use case?”

"We need to avoid unnecessary re-allocations, Snowball. It's more efficient this way. Remember day 2 when Santa was mad at us for a simple clone on a damn String? It wasn't even that big of a deal!"

“Fine! You're right, Santa hates clones.”

“I challenge you, Snowball. Write a function that returns the longer string without any re-allocation. Trim the strings, compare their lengths, and make sure it doesn't involve cloning or creating new allocations.”

The two bickered about ownership, lifetimes, and why Snowball wasn’t using Arch Linux for the next hour.

Now it’s your turn. Can you help Snowball write the function and put Blitzen in his place? Show that junior developers can handle lifetimes too! Try to finish the function longer_wish.

Requirements

If s1 is longer than s2, return a reference to s1 otherwise return a reference to s2 inside a Some variant.
If both slices have the same length, return None.
Any white spaces in the beginning or end of the string should be trimmed.

Good Luck!

Hints

Click here to open the hints

Use the trim() method to remove any white spaces from the beginning or end of the string. e.g. s1.trim().
Use the chars() method to get the UTF-8 characters in the string slice. e.g. s1.chars().
Use the count() method to get the number of chracters in the string slice. e.g. s1.chars().count().
To return a Some variant, you can use the Some(s1) syntax.

Editor not available on Mobile!

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

Solutions

PierreBhs

2 days ago

4.53ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let s1 = s1.trim();
    let s2 = s2.trim();
    if s1.chars().count() == s2.chars().count() {
        return None;
    }
    if s1.chars().count() > s2.chars().count() {
        return Some(&s1);
    }
    Some(&s2)
}

sam

nextbysam

2 days ago

3.60ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let s1_trimmed = s1.trim();
    let s2_trimmed = s2.trim();
    if s1_trimmed.chars().count()>s2_trimmed.chars().count() {
        Some(s1_trimmed)
    } 
    else if s2_trimmed.chars().count()>s1_trimmed.chars().count() {
        Some(s2_trimmed)
    }
    else {
        None
    }
}

Dave Weston

dtweston

4 days ago

3.28ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let len1 = s1.trim().chars().count();
    let len2 = s2.trim().chars().count();
    if len1 > len2 {
        return Some(s1)
    } else if len2 > len1 {
        return Some(s2)
    }
    None
}

Dani Gámez Franco

Danziger

4 days ago

3.63ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // O(n) instead of O(1), but needed as .len() returns the number of bytes, so it doesn't
    // work with unicode text.
    let s1_size = s1.trim().chars().count();
    let s2_size = s2.trim().chars().count();
    if s1_size == s2_size {
        return None;
    }
    return if s1_size > s2_size {
        Some(s1)
    } else {
        Some(s2)
    };
}

Ross

xenon87

5 days ago

3.62ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let dif:i32 = s1.trim().chars().count() as i32 - s2.trim().chars().count() as i32;
    if dif == 0 {
        None
    } else if dif > 0 {
        Some(s1.trim())
    } else {
        Some(s2.trim())
    }
}

Asrul Firdaus

AsrulF

5 days ago

3.72ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let s1_trim = s1.trim().chars().count();
    let s2_trim = s2.trim().chars().count();
    if s1_trim == s2_trim {
        None
    } else if s1_trim > s2_trim {
        Some(s1)
    } else if s1_trim < s2_trim {
        Some(s2)
    } else {
        None
    }
}

Ivan Bykov

renbrek

6 days ago

9.56ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    if s1.trim().len() == s2.trim().len() {
        return None;
    }
    
    if s1.trim().chars().count() > s2.trim().chars().count() {
        return Some(s1);
    } else {
        return Some(s2);
    }
}

Ramon Silva

rsilva1

7 days ago

3.70ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
use std::cmp::Ordering;
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let s1_count = s1.trim().chars().count();
    let s2_count = s2.trim().chars().count();
    match s1_count.cmp(&s2_count) {
        Ordering::Equal => None,
        Ordering::Less => Some(s2),
        Ordering::Greater => Some(s1),
    }
}

Anthony Young

A-Young-Git

10 days ago

3.75ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let tmp_s1 = s1;
    let tmp_s2 = s2;
    let s1 = s1.trim().chars().count();
    let s2 = s2.trim().chars().count();
    if s1 == s2 {
        return None
    }
    if s1 > s2 {
        return Some(tmp_s1)
    } else {
        return Some(tmp_s2)
    }
}

Se7enseads

10 days ago

3.74ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let s_one = s1.trim().chars().count(); 
    let s_two = s2.trim().chars().count();
    if s_one > s_two {
        Some(s1)
    } else if s_one < s_two {
        Some(s2)
    } else {
        None
    }
}

Felix Paetow

hoall

11 days ago

4.49ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let s1trimt = s1.trim();
    let s2trimt = s2.trim();
    let len_s1 = s1trimt.chars().count();
    let len_s2 = s2trimt.chars().count();
    if len_s1 > len_s2 {
        Some(s1trimt)
    } else if len_s1 < len_s2 {
        Some(s2trimt)
    } else {
        None
    }
}

nx0ly

12 days ago

3.55ms

87.95kb

pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    use std::cmp::Ordering;
    let s1_s = s1.trim().chars().count();
    let s2_s = s2.trim().chars().count();
    match s1_s.cmp(&s2_s) {
        Ordering::Equal => None,
        Ordering::Greater => Some(s1),
        Ordering::Less => Some(s2)
    }
}

nx0ly

12 days ago

3.48ms

87.95kb

use std::str::from_utf8;
// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let a = s1.trim().chars().count();
    let b = s2.trim().chars().count();
    if a < b {
        return Some(s2);
    } else if b < a {
        return Some(s1);
    } else {
        return None;
    }
}

Pieter-Jan van Dam

pjvandam

16 days ago

3.54ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let len1 = s1.trim().chars().count();
    let len2 = s2.trim().chars().count();
    // Your code here
    if len1 == len2 {
        return None
    } else if len1 > len2 {
        return Some(s1)
    } else {
        return Some(s2)
    }
}

Chawin Chaisongkram

chawinkn

17 days ago

3.99ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    match s1.trim().chars().count().cmp(&s2.trim().chars().count()) {
        std::cmp::Ordering::Greater => Some(s1),
        std::cmp::Ordering::Less => Some(s2),
        _ => None,
    }
}

Chawin Chaisongkram

chawinkn

17 days ago

3.58ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    if s1.trim().chars().count() == s2.trim().chars().count() {
        None
    } else if s1.trim().chars().count() > s2.trim().chars().count() {
        Some(s1)
    } else {
        Some(s2)
    }
}

nurs

18 days ago

3.47ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    match (s1.trim().chars().count(), s2.trim().chars().count()) {
        (a, b) if a > b => Some(s1),
        (a, b) if a < b => Some(s2),
        _ => None
    }
}

nurs

18 days ago

5.54ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let s1_t = s1.trim();
    let s2_t = s2.trim();
    let s1_count = s1_t.chars().count();
    let s2_count = s2_t.chars().count();
    if s1_count > s2_count {
        Some(s1)
    } else if s1_count < s2_count {
        Some(s2)
    } else {
        None
    }
}

yuvicc

19 days ago

3.78ms

88.33kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    println!("s1 : {}", s1);
    println!("s2: {}", s2);
    if s1.trim().chars().count() > s2.trim().chars().count() {
        Some(&s1)
    } else if s1.trim().chars().count() < s2.trim().chars().count(){
        Some(&s2.trim())
    } else {
        None
    }
}

Octave

BadyJoke

19 days ago

4.15ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let s1_len = s1.trim().chars().count();
    let s2_len = s2.trim().chars().count();
    if s1_len == s2_len {
        return None
    }
    else if s1_len < s2_len {
        return Some(s2)
    } else {
        return Some(s1)
    }
}

Nguyen Ky Tri

tringuyenarup

20 days ago

5.07ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let s1_count = s1.trim().chars().count();
    let s2_count = s2.trim().chars().count();
    if s1_count > s2_count {
        return Some(s1.trim());
    }else if s2_count > s1_count {
        return Some(s2.trim());
    }
    None
}

Ho Chun Lau

kylelau519

21 days ago

3.95ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    if s1.trim().chars().count() > s2.trim().chars().count(){
        return Some(s1);
    }
    else if s2.trim().chars().count() > s1.trim().chars().count(){
        return Some(s2);
    }
    
    None
}

luke-nigro

21 days ago

5.85ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let s1_len: u32 = s1.trim().chars().count() as u32;
    let s2_len: u32 = s2.trim().chars().count() as u32;
    if s1_len == s2_len {
        None
    } else if s1_len > s2_len {
        Some(&s1)
    } else {
        Some(&s2)
    }
}

Daffa Karyudi

KeyCode17

22 days ago

3.83ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let strim1 = s1.trim().chars().count();
    let strim2 = s2.trim().chars().count();
    let diff: i8 = strim1 as i8 - strim2 as i8;
    let value = diff.signum();
    match value {
        1 => Some(s1),
        -1 => Some(s2),
        _ => None
    }
}

Dylan Crees

drcrees

23 days ago

3.78ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    if s1.trim().chars().count() == s2.trim().chars().count() {
        return None;
    }
    if s1.trim().chars().count() > s2.trim().chars().count() {
        return Some(s1);
    }
    Some(s2)
}

Volodymyr Koreniev

vkorenev

24 days ago

3.56ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let s1 = s1.trim();
    let s2 = s2.trim();
    if s1.len() == s2.len() {
        None
    } else if s1.chars().count() > s2.chars().count() {
        Some(s1)
    } else {
        Some(s2)
    }
}

petrokropyvatablet-dotcom

a month ago

4.05ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let len1 = s1.trim().chars().count();
    let len2 = s2.trim().chars().count();
    if len1 == len2 {
        None
    } else if len1 > len2 {
        Some(s1.trim())
    } else {
        Some(s2.trim())
    }
}

blackdeath1346

a month ago

5.34ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> 
{
    let s1_t=s1.trim();
    let s2_t=s2.trim();
    if s1_t.chars().count()>s2_t.chars().count()
    {
        return Some(s1);
    }
    else if s2_t.chars().count()>s1_t.chars().count()
    {
        return Some(s2);
    }
    else 
    {
        return None;
    }
    // Your code here
}

wdcs-tusharnagar

a month ago

4.05ms

87.95kb


// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    
    if s1.trim().chars().count()>s2.trim().chars().count() {
        Some(s1)
    }else if s2.trim().chars().count()> s1.trim().chars().count() {
        Some(s2)
    }else {
        None
    }
}
/* 
// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let s1=s1.trim();
    let s2=s2.trim();
    
    if s1.len()>s2.len() {
        Some(s1)
    }else if s2.len()> s1.len() {
        Some(s2)
    }else {
        None
    }
}
 */

StevenCanDrink

a month ago

4.14ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let trim_s1 = s1.trim().chars().count();
    let trim_s2 = s2.trim().chars().count();
    match (trim_s1 > trim_s2, trim_s1 < trim_s2, trim_s1 == trim_s2) {
        (true, false, false) => Some(s1),
        (false, true, false) => Some(s2),
        (_, _, true) => None,
        (_, _, _) => None,
    }
}

jfloresremar

a month ago

4.02ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let count1 = s1.trim().chars().count();
    let count2 = s2.trim().chars().count();
    if count1 == count2 {
        None
    } else if count1 > count2 {
        Some(s1)
    } else {
        Some(s2)
    }
}

Erik Zhao

zhaoerik

a month ago

4.13ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    if s1.trim().chars().count() > s2.trim().chars().count() {
        return Some(s1);
    } else if s1.trim().chars().count() < s2.trim().chars().count() {
        return Some(s2);
    } else {
        return None;
    }
}

Alex Conley

aconley

2 months ago

5.32ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let s1_len = s1.trim().chars().count();
    let s2_len = s2.trim().chars().count();
    if s1_len > s2_len {
        Some(s1)
    } else if s2_len > s1_len {
        Some(s2)
    } else {
        None
    }
}

msned

2 months ago

3.67ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    if s1.trim().chars().count() > s2.trim().chars().count(){
        Some(s1)
    }else if s1.trim().chars().count() < s2.trim().chars().count(){
        Some(s2)
    } else{
        None
    }
}

asdf

nitipot

2 months ago

5.83ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    if s1.trim().chars().count() > s2.trim().chars().count() {
        return Some(s1);
    } else if s1.trim().chars().count() < s2.trim().chars().count() {
        return Some(s2);
    } else {return None; }
}

TheJanzap

2 months ago

4.46ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let trim_s1 = s1.trim();
    let trim_s2 = s2.trim();
    if trim_s1.len() == trim_s2.len() { return None; }
    if trim_s1.chars().count() > trim_s2.chars().count() { Some(s1) } else { Some(s2) }
}

Emre Erbekin

erbekin

2 months ago

4.96ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let len1 = s1.trim().chars().count();
    let len2 = s2.trim().chars().count();
    if len1 > len2 {
        Some(s1)
    } else if len2 > len1 {
        Some(s2)
    } else {
        None
    }
}

rap1 ラピ

srcrapi

2 months ago

3.50ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code her
    let s1 = s1.trim();
    let s2 = s2.trim();
    let s1_len = s1.chars().count();
    let s2_len = s2.chars().count();
    if s1_len == s2_len {
        return None;
    }
    if s1_len > s2_len {
        Some(s1)
    } else {
        Some(s2)
    }
}

lleongch

2 months ago

4.18ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
       if s1.trim().chars().count() > s2.trim().chars().count() {
        Some(s1)
    } else if s2.trim().chars().count() > s1.trim().chars().count() {
        Some(s2)
    } else {
        None
    }
}

GavFred

2 months ago

3.37ms

88.57kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let s1_trimmed = s1.trim();
    let s2_trimmed = s2.trim();
    let s1_len = s1_trimmed.chars().count();
    let s2_len = s2_trimmed.chars().count();
    println!("s1:'{s1}' ({s1_len})  s2:'{s2}' ({s2_len})");
    return if s1_len > s2_len {
        Some(s1_trimmed)
    } else if s2_len > s1_len {
        Some(s2_trimmed)
    } else {
        None
    }
}

GavFred

2 months ago

4.07ms

88.57kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let s1_trimmed = s1.trim();
    let s2_trimmed = s2.trim();
    let s1_len = s1_trimmed.chars().count();
    let s2_len = s2_trimmed.chars().count();
    println!("s1:'{s1}' ({s1_len})  s2:'{s2}' ({s2_len})");
    return if s1_len > s2_len {
        Some(s1_trimmed)
    } else if s2_len > s1_len {
        Some(s2_trimmed)
    } else {
        None
    }
}

Smith, Taylor

a647965_fidelity

2 months ago

3.62ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let first_len = s1.trim().chars().count();
    let second_len = s2.trim().chars().count();
    if first_len == second_len {
        None
    } else if first_len > second_len {
        Some(s1)
    } else {
        Some(s2)
    }
}

Keegan Conlee

dacid44

2 months ago

3.91ms

87.95kb

use std::cmp::Ordering;
// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let s1 = s1.trim();
    let s2 = s2.trim();
    match s1.chars().count().cmp(&s2.chars().count()) {
        Ordering::Greater => Some(s1),
        Ordering::Less => Some(s2),
        Ordering::Equal => None,
    }
}

Andrea Zoleo

andrea-zoleo

2 months ago

3.77ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let l1 = s1.trim().chars().count();
    let l2 = s2.trim().chars().count();
    if l1 == l2 {
        None
    } else if l1 > l2 {
        Some(s1)
    } else {
        Some(s2)
    }
}

Yashwanth

Yash981

2 months ago

6.43ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    if s1.trim().chars().count() > s2.trim().chars().count() {
        Some(s1)
    } else if s2.trim().chars().count() > s1.trim().chars().count() {
        Some(s2)
    } else {
        None
    }
}

kartik adur

kartikadur

2 months ago

3.73ms

87.95kb

use std::cmp::Ordering;
// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let s1_char_count =  s1.trim().chars().count();
    let s2_char_count =  s2.trim().chars().count();
    // Your code here
    match s1_char_count.cmp(&s2_char_count) {
        Ordering::Less => Some(s2),
        Ordering::Equal => None,
        Ordering::Greater => Some(s1),
    }
}

Sebastien Vassal

svassal

2 months ago

4.94ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    let s1_trimmed_length = s1.trim().chars().count();
    let s2_trimmed_length = s2.trim().chars().count();
    if s1_trimmed_length == s2_trimmed_length {
        return None;
    }
    if s1_trimmed_length > s2_trimmed_length {
        Some(s1)
    } else {
        Some(s2)
    }
}

jovanoviccn

2 months ago

3.32ms

87.95kb

use std::cmp::Ordering;
// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    match s1.trim().chars().count().cmp(&s2.trim().chars().count()) {
        Ordering::Equal=>None,
        Ordering::Greater=>Some(s1),
        Ordering::Less=>Some(s2),
    }
}

Fabricio Arend Torres

FabricioArendTorres

2 months ago

5.29ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    if s1.trim().chars().count() > s2.trim().chars().count() {
        return Some(s1)
    } else if s2.trim().chars().count()>s1.trim().chars().count() {
        return Some(s2)
    } else {
        return None
    }
}

Prashant Puri

Prashant-dot1

3 months ago

4.07ms

87.95kb

// Write a function that returns the reference to the longer string
// without any new allocations
pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // Your code here
    let s1_len = s1.trim().chars().count();
    let s2_len = s2.trim().chars().count();
    if s1_len > s2_len {
        Some(s1)
    }
    else if s1_len == s2_len {
        None
    }
    else {
        Some(s2)
    }
}