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

jovanoviccn

a day 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 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> {
    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

9 days 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)
    }
}

Heino Mortensen

hmortensen83

12 days ago

5.60ms

87.95kb

pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    match (s1.trim().chars().count(), s2.trim().chars().count()) {
        (x, y) if x > y => Some(s1.trim()),
        (x, y) if y > x => Some(s2.trim()),
        _ => None,
    }
}

Ranjith Thangavel

RanjithECE24

13 days ago

3.81ms

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

Spheniscine

18 days ago

3.76ms

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

Andreas Lundin

andreaslundin47

19 days ago

17.04ms

87.95kb

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

visanr

20 days ago

3.47ms

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> {
    let s1_len = s1.trim().chars().count();
    let s2_len = s2.trim().chars().count();
    match s1_len.cmp(&s2_len) {
        Ordering::Less => Some(s2.trim()),
        Ordering::Equal => None,
        Ordering::Greater => Some(s1.trim())
    }
    // Your code here
}

palcoo42

21 days ago

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

angalar

22 days ago

3.67ms

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

johndoe30bc

23 days ago

4.10ms

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

Wouter

WouterMartens

24 days ago

3.97ms

87.95kb

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 {
        Some(s2)
    }
}

Khant

Khantdotcom

a month ago

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

Guilherme

GuilhermeGcaires

a month 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> {
    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)
    }
}

mooncaker816

a month ago

3.76ms

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

Youssef Bennour Sahli

youssefbennour

a month ago

3.92ms

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

Roman Dyachuk

Asterrus

a month ago

3.84ms

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

Icarus-15

a month ago

4.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
    match (s1.trim().chars().count(),  s2.trim().chars().count()){
        (a,b) if a > b => Some(s1),
        (a,b) if a < b => Some(s2),
        _ => None,
        
    }
    
}

jcortial

a month ago

3.49ms

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::Less => Some(s2),
     Ordering::Equal => None,
     Ordering::Greater => Some(s1),
   }
}

jcortial

a month ago

4.28ms

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::Less => Some(s2),
     Ordering::Equal => None,
     Ordering::Greater => Some(s1),
   }
}

sjmellor

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

sjmellor

a month 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> {
    // 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 {
        Some(s2)
    }
    else {
        None
    }
}

Chloe

chloecat34

a month ago

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

tdoan

a month ago

4.83ms

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

brucecox01

a month ago

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

Sergey Chelak

SergeyChelak

a month ago

4.08ms

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 length = |s: &str| -> usize {
        s.trim().chars().count()
    };
    let len1 = length(s1);
    let len2 = length(s2);
    use std::cmp::Ordering::*;
    match len1.cmp(&len2) {
        Equal => None,
        Less => Some(s2),
        Greater => Some(s1)
    }
}

Sergey Chelak

SergeyChelak

a month ago

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

Felix

FelixMaetzler

2 months ago

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

DilligentDisaster

2 months ago

5.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> {
    // Your code here
    if s1.trim().chars().count() > s2.trim().chars().count() {
        Some(&s1.trim())
    }
    else {
        if s2.trim().chars().count() > s1.trim().chars().count() {
            Some(&s2.trim())
        }
        else {
            None
        }
    }
}

Philippe Massicotte

PMassicotte

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

Kr0wZ

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

UncleScientist

2 months ago

3.43ms

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

helgesander

2 months ago

4.20ms

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::Less => Some(s2),
        Ordering::Equal => None,
        Ordering::Greater => Some(s1),
        _ => None
    }
}

0x0f1

Paul4673

2 months ago

6.35ms

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

Kristupas Arifovas

Quikmove

2 months ago

5.61ms

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

HubertBL47

2 months ago

3.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> {
    let s1 = s1.trim();
    let s2 = s2.trim();
    // use chars().count() instead of len() 
    // because we want the number of char, not the bytes len
    let s1_len = s1.chars().count();
    let s2_len = s2.chars().count();
    match s1_len.cmp(&s2_len) {
        std::cmp::Ordering::Less => Some(s2),
        std::cmp::Ordering::Equal => None,
        std::cmp::Ordering::Greater => Some(s1),
    }
}

AncientSecrets

2 months 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> {
    use std::cmp::Ordering;
    let s1len = s1.trim().chars().count();
    let s2len = s2.trim().chars().count();
    match s1len.cmp(&s2len) {
        Ordering::Greater => Some(s1),
        Ordering::Equal => None,
        Ordering::Less => Some(s2),
    }
}

Camiam144

2 months 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> {
    // Your code here
    let s1trim = s1.trim();
    let s2trim = s2.trim();
    let len_s1 = s1trim.chars().count();
    let len_s2 = s2trim.chars().count();
    if len_s1 > len_s2 {
        Some(s1)
    }
    else if len_s2 > len_s1 {
        Some(s2)
    }
    else {
        None
    }
}

silaskoemen

2 months ago

3.84ms

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

Andrés Pérez

cperez08

2 months ago

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

Hongzhii

2 months ago

3.69ms

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

Hongzhii

2 months 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> {
    // Your code here
    let string1 = s1.trim().chars();
    let string2 = s2.trim().chars();
    if string1.clone().count() == string2.clone().count() {
        None
    } else if string1.clone().count() > string2.clone().count() {
        Some(s1.trim())
    } else {
        Some(s2.trim())
    }
}

Alan Bowman

alanbowman

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

Luigi Terrone

LuigiTer

2 months ago

3.81ms

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

xian ma

xanvcs

2 months ago

3.96ms

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::Greater => Some(s1),
        Ordering::Equal => None,
        _ => Some(s2)
    }
}

xian ma

xanvcs

2 months ago

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

13Noodles

2 months ago

3.82ms

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

Sarthak Mishra

sithtsar

2 months ago

3.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> {
    // 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
   }
}

Anthony

Ashaman00

2 months ago

3.51ms

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

Regulus-Sun

2 months ago

3.78ms

87.95kb


pub fn longer_wish<'a>(s1: &'a str, s2: &'a str) -> Option<&'a str> {
    // len() returns length in bytes, but Rust strings are UTF-8 so may contain multibyte characters.
    // Therefore use chars().count() instead.
    let str1 = s1.trim().chars().count();
    let str2 = s2.trim().chars().count();
    if str1 == str2 {
        None
    } else if str1 > str2 {
        Some(&s1)
    } else {
        Some(&s2)
    }
}