【经典算法】LeetCode 58.最后一个单词的长度(Java/C/Python3/Go实现含注释说明,Easy)

public class Solution {
    public int lengthOfLastWord(String s) {
        int length = 0;
        int i = s.length() - 1;
        
        // 跳过末尾的空格
        while (i >= 0 && s.charAt(i) == ' ') {
            i--;
        }
        
        // 计数最后一个单词的长度
        while (i >= 0 && s.charAt(i) != ' ') {
            length++;
            i--;
        }
        
        return length;
    }
}

#include <string.h>
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;
}

def lengthOfLastWord(s: str) -> int:
    # 去除字符串末尾的空格
    s = s.rstrip()
    # 以空格分割字符串，并取最后一个单词
    last_word = s.split()[-1]
    # 返回最后一个单词的长度
    return len(last_word)

package main
import (
  "strings"
)
func lengthOfLastWord(s string) int {
  // 去除字符串末尾的空格
  s = strings.TrimRight(s, " ")
  // 以空格分割字符串，并取最后一个单词
  words := strings.Split(s, " ")
  lastWord := words[len(words)-1]
  // 返回最后一个单词的长度
  return len(lastWord)
}
func main() {
  // 测试代码
  s := "Hello World"
  length := lengthOfLastWord(s)
  println(length) // 输出: 5
}

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Solution {
    public int lengthOfLastWord(String s) {
        // 正则表达式匹配单词，\b表示单词边界，\w+匹配一个或多个字母、数字或下划线
        Pattern pattern = Pattern.compile("\\b\\w+\\b");
        Matcher matcher = pattern.matcher(s);
        
        int length = 0;
        // 查找所有匹配项
        while (matcher.find()) {
            // 保留最后一个匹配项的长度
            length = matcher.group().length();
        }
        
        return length;
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <regex.h>
int lengthOfLastWord(char *s) {
    regex_t regex;
    regmatch_t match;
    int ret;
    char errbuf[100];
    
    // 编译正则表达式，匹配单词边界内的单词
    ret = regcomp(&regex, "\\b\\w+\\b", REG_EXTENDED);
    if (ret) {
        regerror(ret, &regex, errbuf, sizeof(errbuf));
        fprintf(stderr, "Regex compilation failed: %s\n", errbuf);
        return 0;
    }
    
    int length = 0;
    char *ptr = s;
    // 查找所有匹配项
    while ((ret = regexec(&regex, ptr, 1, &match, 0)) == 0) {
        // 如果找到匹配项，更新长度为当前匹配项的长度
        length = match.rm_eo - match.rm_so;
        // 移动指针到下一个可能的位置
        ptr += match.rm_eo;
    }
    
    // 释放正则表达式对象
    regfree(&regex);
    
    // 如果正则表达式执行失败且不是因为没有更多匹配项，打印错误信息
    if (ret != REG_NOMATCH) {
        regerror(ret, &regex, errbuf, sizeof(errbuf));
        fprintf(stderr, "Regex match failed: %s\n", errbuf);
    }
    
    return length;
}
int main() {
    char s[] = "Hello World";
    int length = lengthOfLastWord(s);
    printf("Length of last word: %d\n", length); // 输出: 5
    return 0;
}

import re
def lengthOfLastWord(s: str) -> int:
    # 使用正则表达式匹配最后一个单词
    last_word = re.search(r'\b\w+\b$', s)
    # 如果找到最后一个单词，返回其长度，否则返回0
    return len(last_word.group()) if last_word else 0

package main
import (
  "fmt"
  "regexp"
)
func lengthOfLastWord(s string) int {
  // 编译正则表达式，匹配单词边界内的单词
  re := regexp.MustCompile(`\b\w+\b`)
  // 查找所有匹配项
  matches := re.FindAllString(s, -1)
  // 如果找到匹配项，返回最后一个匹配项的长度
  if len(matches) > 0 {
    return len(matches[len(matches)-1])
  }
  // 如果没有找到匹配项，返回0
  return 0
}
func main() {
  s := "Hello World"
  length := lengthOfLastWord(s)
  fmt.Println(length) // 输出: 5
}