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

henrikfasth

a day ago

6.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
    let s1_len: usize = s1.trim().chars().count();
    let s2_len: usize = s2.trim().chars().count();
    if s1_len == s2_len {
        None
    } else if s1_len > s2_len {
        Some(s1)
    } else {
        Some(s2)
    }
}

Alon Parag

Alonoparag

a day ago

5.69ms

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> {
    match s1.trim().chars().count().cmp(&s2.trim().chars().count()) {
        Ordering::Greater => {
            Some(&s1)
        }
        Ordering::Equal => {
            None
        }
        Ordering::Less => {
            Some(&s2)
        }
    }
}

vseipelt

2 days ago

8.90ms

87.95kb

use std::cmp::Ordering;
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();
    match s1_len.cmp(&s2_len) {
        Ordering::Less => Some(s2),
        Ordering::Equal => None,
        Ordering::Greater => Some(s1),
    }
}

Zodiacsyndicate

ZodiacSyndicate

3 days ago

7.98ms

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
    match s1.trim().chars().count().cmp(&s2.trim().chars().count()) {
        Ordering::Less => Some(s2),
        Ordering::Equal => None,
        Ordering::Greater => Some(s1),
    }
}

Lucas Igarzabal

RstyDev

4 days ago

6.90ms

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 one = s1.trim();
    let two = s2.trim();
    if one.len() == two.len() {
        return None;
    }
    (one.chars().count() > two.chars().count())
        .then_some(one.trim())
        .or(Some(two.trim()))
}

cesard

cesardtamayo

4 days ago

6.31ms

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
    // Trim whitespace once and store the slices
    let trimmed_s1 = s1.trim();
    let trimmed_s2 = s2.trim();
    
    // Use .chars().count() for accurate length comparison
    let len1 = trimmed_s1.chars().count();
    let len2 = trimmed_s2.chars().count();
    
    // Compare character counts
    if len1 == len2 {
        return None;
    }
    
    if len1 > len2 {
        // Return the slice (s1.trim()) that was determined to be longer
        Some(trimmed_s1) 
    } else {
        // Return the slice (s2.trim()) that was determined to be longer
        Some(trimmed_s2)
    }
}

Mutahir

EldenArgentum

4 days 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 len1 = s1.trim().chars().count();
    let len2 = s2.trim().chars().count();
    if len1 == len2 { return None }
    if len1 > len2 {
        Some(s1)
    }
    else {
        Some(s2)
    }
}

Steve Roe

roedog

4 days ago

5.41ms

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 None;
    }
    if s1.trim().chars().count() < s2.trim().chars().count() {
        return Some(&s2);
    }
    else {
        return Some(&s1);
    }
}

Terje Golden Sæther

Terje-Golden-Saether_navia

4 days ago

5.87ms

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 s1_trimmed.chars().count() < s2_trimmed.chars().count() {
        Some(s2_trimmed)
    }
    else {
        None
    }
}

Foxscotch

foxscotch

4 days ago

6.87ms

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 len1 < len2 {
        Some(s2)
    } else {
        None
    }
}

Øystein B. Haugen

oystein-b-haugen_navia

5 days ago

9.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
    let s1count = s1.trim().chars().count();
    let s2count = s2.trim().chars().count();
    if s1count > s2count {
        return Some(s1);
    } else if s1count == s2count {
        return None;
    }
    return Some(s2);
}

Mykhailo Moroz

imikemo

5 days ago

11.42ms

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
    match s1.trim().chars().count().cmp(&s2.trim().chars().count()) {
        Ordering::Less => Some(s2),
        Ordering::Greater => Some(s1),
        Ordering::Equal => None
    }
}

Øystein Krag

oystein-krag_navia

5 days ago

48.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> {
    let s1 = s1.trim();
    let s2 = s2.trim();
    let len1 = s1.chars().count();
    let len2 = s2.chars().count();
    if len1 == len2 {
        None
    } else if len1 > len2 {
        Some(s1)
    } else {
        Some(s2)
    }
}

Ole Henrik Dahle

oledahle

5 days ago

21.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> {
    let len1:usize = s1.trim().chars().count();
    let len2:usize = s2.trim().chars().count();
    if len1 == len2 {
        return None;
    }
    if len1 > len2 {
        return Some(s1.trim());
    }
    return Some(s2.trim());
}

Hugo Varani

hgvarani

6 days 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> {
    // Your code here
    if s1.trim().chars().count() == s2.trim().chars().count() { return None; }
    if s1.trim().chars().count() > s2.trim().chars().count() {
        Some(s1)
    } else {
        Some(s2)
    }
}

slavaavr

6 days ago

8.12ms

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 = s1.trim();
    let s2 = s2.trim();
    if s1.chars().count() > s2.chars().count() {
        return Some(s1.trim());
    } else if s1.chars().count() < s2.chars().count() {
        return Some(s2.trim());
    }
    return None;
}

Giorgi Grigalashvili

BUGO07

6 days ago

6.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> {
    let t1 = s1.trim().chars().count();
    let t2 = s2.trim().chars().count();
    if t1 > t2 {
        return Some(s1);
    } else if t2 > t1 {
        return Some(s2);
    } else {
        None
    }
}

Edwin

ark930

7 days ago

6.26ms

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 len_s1 = s1.trim().chars().count();
    let len_s2 = s2.trim().chars().count();
    match (len_s1 > len_s2, len_s1 < len_s2) {
        (true, false) => Some(s1),
        (false, true) => Some(s2),
        _ => None,
    }
}

Rob.Bulmer

rbulmer55

7 days ago

5.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> {
    // Your code here
    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)
}

MiikkaVG

8 days ago

5.38ms

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 None;
    }
    if s1.trim().chars().count() > s2.trim().chars().count() {
        return Some(s1);
    }
    Some(s2)
}

Federica Emiliani

femili_nike

8 days ago

4.88ms

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_l = s1.trim().chars().count(); 
    let s2_l = s2.trim().chars().count();
    if s1_l > s2_l {
        Some(s1)
    } 
    else if s1_l < s2_l {
        Some(s2)
    }  
    else {
        None
    }
}

Eduardo Antuña Díez

eduadiez

8 days ago

7.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> {
    if s1.trim().chars().count() == s2.trim().chars().count(){
        return None;
    }else if s1.trim().chars().count() > s2.trim().chars().count(){
        return Some(s1);
    }
    else {
        return Some(s2);
    }
}

PrT15

PratiyushT

8 days ago

7.04ms

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

Jatyn Stacy

Jinglezs

8 days ago

4.80ms

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_length = s1.trim().chars().count();
    let s2_length = s2.trim().chars().count();
    if s1_length == s2_length {
        None
    } else if s1_length < s2_length {
        Some(s2)
    } else {
        Some(s1)
    }
}

Simon Morgan

drguildo

9 days ago

5.22ms

87.95kb

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;
    }
    if s1_len > s2_len { Some(s1) } else { Some(s2) }
}

arvinder-palaha

9 days ago

5.16ms

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 None;
    } else {
        return if len1 > len2 { Some(s1) } else { Some(s2) }
    }
}

arvinderpalahaf1w

9 days ago

5.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> {
    // Your code here
    let s1c = s1.trim().chars().count();
    let s2c = s2.trim().chars().count();
    if s1c > s2c {
        return Some(s1);
    } else if s2c > s1c {
        return Some(s2);
    } else {
        return None;
    }
}

psh

pshorge

9 days ago

5.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 len1=s1.trim().chars().count();
   let len2=s2.trim().chars().count();
   if len1 == len2 {
        None
   }
   else  {
        Some(if len1 > len2 {s1} else {s2})
   }
   
}

Chenyao Yu

chenyaoy

10 days ago

5.59ms

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
    match s1.trim().chars().count().cmp(&s2.trim().chars().count()) {
        Ordering::Equal => None,
        Ordering::Greater => Some(s1),
        Ordering::Less => Some(s2)
    }
}

MathDev0

11 days ago

6.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
    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
    }
}

MrSarcasticSloth

11 days ago

5.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
    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 {
        return Some(s1)
    }
    Some(s2)
}

Jungseok Lee

jungseoklee

12 days ago

6.48ms

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 herer
    let x = s1.trim().chars().count();
    let y = s2.trim().chars().count();
    if x == y {
        None
    } else if x > y {
        Some(s1)
    } else {
        Some(s2)
    }
}

BlueFox1616

13 days ago

7.11ms

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 numbr1 = s1.trim().chars().count();
    let numbr2 = s2.trim().chars().count();
    let mut biggerString = s1;
    if numbr2 > numbr1 {
        biggerString = s2;
    }
    if numbr1 == numbr2 {
        return None;
    }
    Some(biggerString)
}

Olivier Neyret

OlivierNeyret

13 days ago

7.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
    let s1_count = s1.trim().chars().count();
    let s2_count = s2.trim().chars().count();
    if s1_count == s2_count {
        return None;
    }
    else if s1_count > s2_count {
        Some(s1)
    }
    else {
        Some(s2)
    }
}

Tongue_chaude

Tonguechaude

13 days ago

18.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_length = s1.trim().chars().count();
    let s2_legnth = s2.trim().chars().count();
    if s1_length == s2_legnth { return None; }
    if s1_length > s2_legnth { Some(s1) } else { Some(s2) }
}

Jacky Li

Jacky-Lzx

13 days ago

6.44ms

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_t = s1.trim();
    let s2_t = s2.trim();
    let s1_l = s1_t.chars().count();
    let s2_l = s2_t.chars().count();
    if s1_l > s2_l {
        Some(s1_t)
    } else if s1_l < s2_l {
        Some(s2_t)
    } else {
        None
    }
}

GreenestBeen

13 days ago

7.66ms

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();
    let s1_len = s1.chars().count();
    let s2_len = s2.chars().count();
    if s1_len > s2_len {
        Some(s1)
    }
    else if s2_len > s1_len {
        Some(s2)
    }
    else {
        None
    }
}

michdorf

14 days ago

8.44ms

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 s1len = s1.trim().chars().count();
    let s2len = s2.trim().chars().count();
    match s1len > s2len {
        true => return Some(&s1),
        false => {
            if s1len == s2len {
                return None;
            } else {
                return Some(&s2);
            }
        }
    }
}

nataziel

15 days 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> {
    // Your code here
    let s1_trimmed = s1.trim();
    let s1_count = s1_trimmed.chars().count();
    let s2_trimmed = s2.trim();
    let s2_count = s2_trimmed.chars().count();
    if s1_count > s2_count {
        Some(s1_trimmed)
    } else if s1_count == s2_count {
        None
    } else {
        Some(s2_trimmed)
    }
}

Kevin Watson

Kevmo92

16 days ago

5.16ms

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_count = s1.trim().chars().count();
    let s2_count = s2.trim().chars().count();
    if s1_count == s2_count {
        return None;
    } else if s1_count > s2_count {
        return Some(s1);
    } else {
        return Some(s2);
    }
}

cakeinspace

17 days ago

4.86ms

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: usize = s1.trim().chars().count();
    let s2_len: usize = s2.trim().chars().count();
    if s1_len==s2_len{
        return None;
    }
    else if s1_len > s2_len{
        return Some(s1);
    }
    else{
        return Some(s2);
    }
}

cakeinspace

17 days ago

4.65ms

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: usize = s1.trim().chars().count();
    let s2_len: usize = s2.trim().chars().count();
    if s1_len==s2_len{
        return None;
    }
    else if s1_len > s2_len{
        return Some(&s1);
    }
    else{
        return Some(&s2);
    }
}

varghamarci

19 days ago

7.03ms

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 str1 = s1.trim().chars().count();
        let str2 = s2.trim().chars().count();
        if str1 > str2 {
            return Some(&s1);
        }
        if str1 < str2 {
            return Some(&s2);
        }
        return None;
    }

Connor Barrett

cbarrett-livefront

19 days ago

4.80ms

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 s1t: &str = s1.trim();
    let s2t: &str = s2.trim();
    let s1chars: usize = s1t.chars().count();
    let s2chars: usize = s2t.chars().count();
    if s1chars == 0 && s2chars == 0 {
        None
    }
    else if s1chars > s2chars {
        Some(s1)
    }
    else if s2chars > s1chars {
        Some(s2)
    }
    else {
        None
    }
}

Jérémie Bolduc

jeremiebolduc

23 days ago

5.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 s1_trimmed = s1.trim().chars();
    let s2_trimmed = s2.trim().chars();
    if s1_trimmed.clone().count() > s2_trimmed.clone().count() {
        return Some(s1)
    } else if s1_trimmed.count() < s2_trimmed.count() {
        return Some(s2)
    } else {
        return None
    }
}

Jesse Wei

jesse-wei

23 days ago

4.23ms

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() {
        None
    } else if s1.chars().count() > s2.chars().count() {
        Some(s1.trim())
    } else {
        Some(s2.trim())
    }
}

Anti Räis

antirais

a month ago

4.48ms

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 {
        None
    } else if s1_len > s2_len {
        Some(s1)
    } else {
        Some(s2)
    }
}

Ishaan-2312

a month ago

5.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
    let new_s1 = s1.trim();
    let new_s2 = s2.trim();
    let num_chars1: u32 = new_s1.chars().count() as u32;
    let num_chars2: u32 = new_s2.chars().count() as u32;
    
    if num_chars1 < num_chars2 {
        return Some(s2)
    } 
    if num_chars2 < num_chars1{
        return Some(s1)
    }
    return None
}

Gavin Chen

TheRealGchen

a month ago

3.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
    let new_s1 = s1.trim();
    let new_s2 = s2.trim();
    let num_chars1: u32 = new_s1.chars().count() as u32;
    let num_chars2: u32 = new_s2.chars().count() as u32;
    
    if num_chars1 < num_chars2 {
        return Some(s2)
    } 
    if num_chars2 < num_chars1{
        return Some(s1)
    }
    return None
}

Atanas Krondev

AtanasKrondev

a month ago

3.55ms

87.95kb

use std::cmp::Ordering;
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();
    match len1.cmp(&len2) {
        Ordering::Greater => Some(s1),
        Ordering::Less => Some(s2),
        Ordering::Equal => None,
    }
}