2024-11-27：字符串的分数。用go语言，给定一个字符串 s，我们可以定义其“分数”为相邻字符的 ASCII 码差值绝对值的总和。

请计算并返回字符串 s 的分数。

输入：s = “hello”。

输出：13。

解释：

s 中字符的 ASCII 码分别为：‘h’ = 104 ，‘e’ = 101 ，‘l’ = 108 ，‘o’ = 111 。所以 s 的分数为 |104 - 101| + |101 - 108| + |108 - 108| + |108 - 111| = 3 + 7 + 0 + 3 = 13 。

答案2024-11-27：

chatgpt

题目来自leetcode3110。

大体步骤如下：

1.输入处理：

• 我们接收到一个字符串 ( s )，例如输入示例中提供的 "hello"。

2.初始化分数：

• 初始化一个计数器，用于存储分数。这个计数器 ans 的初始值为 0。

3 遍历字符串：

3.1.使用一个循环，从字符串的第二个字符（即索引1）开始遍历到字符串的最后一个字符：

3.1.1.for i := 1; i < len(s); i++：循环的索引 i 从 1 开始，直到 ( s ) 的长度减 1（即最后一个字符的索引）。

4 计算 ASCII 差值：

4.1.在每次循环中，计算相邻两个字符的 ASCII 码差值的绝对值：

4.1.1.取出当前字符（s[i]）和前一个字符（s[i-1]），将这两个字符转换为整数（它们的 ASCII 码值），然后计算它们之间的差值：

4.1.1.abs(int(s[i-1]) - int(s[i]))：这里 abs 是一个辅助函数，用于计算一个整数的绝对值。

4.1.2.将计算得到的绝对值累加到 ans 中。

5.返回结果：

• 当循环完成后，ans 中存储的值就是字符串的分数。使用 return 返回该值。

示例计算：

以字符串 s = "hello" 为例：

• ASCII 码：

  • ‘h’ = 104
  • ‘e’ = 101
  • ‘l’ = 108
  • ‘l’ = 108
  • ‘o’ = 111

• 计算绝对差值：

  1. |h - e| = |104 - 101| = 3
  2. |e - l| = |101 - 108| = 7
  3. |l - l| = |108 - 108| = 0
  4. |l - o| = |108 - 111| = 3

• 累加结果：3 + 7 + 0 + 3 = 13

时间复杂度：

• 时间复杂度：O(n)。在最坏情况下，需要遍历整个字符串一次，其中 ( n ) 是字符串的长度。因此，时间复杂度是线性的，O(n)。

空间复杂度：

• 额外空间复杂度：O(1)。在计算过程中，只使用了一个整数变量 ans 来存储结果，不需要使用其他额外的数据结构，因此额外空间复杂度是常数，即 O(1)。

综上所述，所述算法的时间复杂度为 O(n)，而空间复杂度为 O(1)。

Go完整代码如下：

package main

import (
	"fmt"
)

func scoreOfString(s string) (ans int) {
	for i := 1; i < len(s); i++ {
		ans += abs(int(s[i-1]) - int(s[i]))
	}
	return
}

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

func main() {
	s := "hello"
	fmt.Println(scoreOfString(s))
}

Rust完整代码如下：

fn score_of_string(s: &str) -> i32 {
    let mut ans = 0;

    for i in 1..s.len() {
        let prev_char = s.chars().nth(i - 1).unwrap();
        let curr_char = s.chars().nth(i).unwrap();
        ans += (prev_char as i32 - curr_char as i32).abs();
    }

    ans
}

fn main() {
    let s = "hello";
    println!("{}", score_of_string(s));
}