Length Of Last Word

                                            
class Solution {
public:
    int lengthOfLastWord(string s) {
        int length = 0;
        int i = s.length() - 1;
        
        while (i >= 0 && s[i] == ' ') {
            i--;
        }
        
        while (i >= 0 && s[i] != ' ') {
            length++;
            i--;
        }
        
        return length;
    }
};

                                            
class Solution {
    public int lengthOfLastWord(String s) {
        String[] words = s.trim().split(" ");
        return words[words.length - 1].length();
    }
}

                                            
class Solution(object):
    def lengthOfLastWord(self, s):
        """
        :type s: str
        :rtype: int
        """
        words = s.strip().split()
        return len(words[-1]) if words else 0

                                            
int lengthOfLastWord(char* s) {
    int length = 0;
    int i = strlen(s) - 1;
    
    while (i >= 0 && s[i] == ' ') {
        i--;
    }
    
    while (i >= 0 && s[i] != ' ') {
        length++;
        i--;
    }
    
    return length;
}

                                            
public class Solution {
    public int LengthOfLastWord(string s) {
        s = s.Trim();
        int length = 0;
        for (int i = s.Length - 1; i >= 0; i--) {
            if (s[i] == ' ') {
                break;
            }
            length++;
        }
        return length;
    }
}

                                            
/**
 * @param {string} s
 * @return {number}
 */
var lengthOfLastWord = function(s) {
    const words = s.trim().split(" ");
    return words[words.length - 1].length;
};

                                            
function lengthOfLastWord(s: string): number {
    const words = s.trim().split(' ');
    return words[words.length - 1].length;
};

                                            
class Solution {
    /**
     * @param String $s
     * @return Integer
     */
    function lengthOfLastWord($s) {
        $words = explode(" ", trim($s));
        return strlen(end($words));
    }
}

                                            
class Solution {
    func lengthOfLastWord(_ s: String) -> Int {
        let trimmedString = s.trimmingCharacters(in: .whitespaces)
        guard let lastWord = trimmedString.components(separatedBy: " ").last else { return 0 }
        return lastWord.count
    }
}

                                            
class Solution {
    fun lengthOfLastWord(s: String): Int {
        var length = 0
        var i = s.length - 1
        
        while (i >= 0 && s[i] == ' ') {
            i--
        }
        
        while (i >= 0 && s[i] != ' ') {
            length++
            i--
        }
        
        return length
    }
}

                                            
class Solution {
  int lengthOfLastWord(String s) {
    List<String> words = s.trim().split(" ");
    return words.last.length;
  }
}

                                            
func lengthOfLastWord(s string) int {
    length := 0
    foundWord := false

    for i := len(s) - 1; i >= 0; i-- {
        if s[i] != ' ' {
            foundWord = true
            length++
        } else if foundWord {
            break
        }
    }

    return length
}

                                            
# @param {String} s
# @return {Integer}
def length_of_last_word(s)
    words = s.split
    words.empty? ? 0 : words.last.length
end

                                            
object Solution {
    def lengthOfLastWord(s: String): Int = {
        s.trim.split(" ").last.length
    }
}

                                            
impl Solution {
    pub fn length_of_last_word(s: String) -> i32 {
        let mut result = 0;
        
        for c in s.trim().chars().rev() {
            if c == ' ' {
                break;
            }
            result += 1;
        }
        
        result
    }
}

                                            
(define/contract (length-of-last-word s)
  (-> string? exact-integer?)
  (let* ((words (regexp-match* #rx"[a-zA-Z]+" s))
         (last-word (last-pair words)))
    (if last-word
        (string-length (car last-word))
        0)))

                                            
defmodule Solution do
  @spec length_of_last_word(s :: String.t) :: integer
  def length_of_last_word(s) do
    s
    |> String.trim()
    |> String.split(" ")
    |> Enum.reverse()
    |> Enum.find(&(&1 != ""))
    |> String.length()
  end
end

To solve this coding challenge, we need to determine the length of the last word in a given string. The string consists of words separated by spaces, and it may have leading or trailing spaces. Our solution should effectively handle these aspects.

Explanation:

We start with a string

s

, and our objective is to return the length of the last word. A word is defined as a sequence of non-space characters surrounded by spaces or edges of the string. Here are the detailed steps to solve this problem:

Trim Leading and Trailing Spaces : We should remove any leading or trailing spaces from the string to ensure that spaces at the ends do not affect our word identification.
Split the String into Words : We split the cleaned string into a list of words by spaces. This creates segments of non-space characters (i.e., words).
Identify the Last Word : Since we're interested in the length of the last word, we can directly access the last element of the list of words.
Calculate Length : Finally, we calculate the length of this last word.

The constraints guarantee that the string will have at least one word, so we don't need to handle the case of an empty string.

Pseudocode with Comments:

                                            
# Trim leading and trailing spaces from the input string s
cleaned_string = s.strip() 

# Split the cleaned string into a list of words
words_list = cleaned_string.split(" ") 

# Access the last word from the list of words
last_word = words_list[-1] 

# Calculate the length of the last word
last_word_length = length(last_word) 

# Return the length of the last word
return last_word_length

Step-by-Step Explanation:

Trim Leading and Trailing Spaces : Use the
strip

method to remove spaces from both ends of the string. This ensures the string only contains words separated by spaces without any leading or trailing spaces.

                                            
trimmed_string = strip(s)

Split the String into Words : Use the
split

method to divide the string into a list of words based on spaces. The result is a list where each element is a word.

                                            
words = split(trimmed_string, " ")

Identify the Last Word : Access the last element of the list, which corresponds to the last word in the string.

                                            
last_word = words[length(words) - 1]

Calculate Length : Determine the length of this last word using the
length

function.

                                            
length_last_word = length(last_word)

Return the Length : Return the calculated length.

                                            
return length_last_word

Combining Detailed Steps in Pseudocode:

                                            
# Step 1: Remove leading and trailing spaces from the string 
cleaned_string = s.strip() 

# Step 2: Split the cleaned string into a list of words 
words_list = cleaned_string.split(" ") 

# Step 3: Retrieve the last word from the list of words 
last_word = words_list[-1] 

# Step 4: Calculate the length of the last word 
last_word_length = length(last_word) 

# Step 5: Return the length of the last word 
return last_word_length

By following these detailed steps, we ensure that we correctly find and return the length of the last word in the given string

s

. This pseudocode efficiently handles the requirements and constraints provided in the coding challenge by ensuring all edge cases related to spaces are adequately dealt with.