feat: add solutions to lc problem: No.0848

No.0848.Shifting Letters

Author: yanglbme

solution/0800-0899/0848.Shifting Letters/README.md

@@ -55,22 +55,103 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：后缀和**
+
+对于字符串 $s$ 中的每个字符，我们需要计算其最终的偏移量，即 `shifts[i]` 与 `shifts[i + 1]` 与 `shifts[i + 2]` ... 的和。我们可以使用后缀和的思想，从后往前遍历 `shifts`，计算每个字符的最终偏移量，然后对 $26$ 取模，得到最终的字符。
+
+时间复杂度 $O(n)$，其中 $n$ 为字符串 $s$ 的长度。忽略答案的空间消耗，空间复杂度 $O(1)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Solution:
+    def shiftingLetters(self, s: str, shifts: List[int]) -> str:
+        n = len(s)
+        d = [0] * (n + 1)
+        for i, c in enumerate(s):
+            v = ord(c) - ord('a')
+            d[i] += v
+            d[i + 1] -= v
+        for i, x in enumerate(shifts):
+            d[0] += x
+            d[i + 1] -= x
+        t = 0
+        ans = []
+        for i in range(n):
+            d[i] %= 26
+            ans.append(ascii_lowercase[d[i]])
+            d[i + 1] += d[i]
+        return ''.join(ans)
+```
 
+```python
+class Solution:
+    def shiftingLetters(self, s: str, shifts: List[int]) -> str:
+        n, t = len(s), 0
+        s = list(s)
+        for i in range(n - 1, -1, -1):
+            t += shifts[i]
+            j = (ord(s[i]) - ord('a') + t) % 26
+            s[i] = ascii_lowercase[j]
+        return ''.join(s)
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public String shiftingLetters(String s, int[] shifts) {
+        char[] cs = s.toCharArray();
+        int n = cs.length;
+        long t = 0;
+        for (int i = n - 1; i >= 0; --i) {
+            t += shifts[i];
+            int j = (int) ((cs[i] - 'a' + t) % 26);
+            cs[i] = (char) ('a' + j);
+        }
+        return String.valueOf(cs);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    string shiftingLetters(string s, vector<int>& shifts) {
+        long long t = 0;
+        int n = s.size();
+        for (int i = n - 1; ~i; --i) {
+            t += shifts[i];
+            int j = (s[i] - 'a' + t) % 26;
+            s[i] = 'a' + j;
+        }
+        return s;
+    }
+};
+```
 
+### **Go**
+
+```go
+func shiftingLetters(s string, shifts []int) string {
+	t := 0
+	n := len(s)
+	cs := []byte(s)
+	for i := n - 1; i >= 0; i-- {
+		t += shifts[i]
+		j := (int(cs[i]-'a') + t) % 26
+		cs[i] = byte('a' + j)
+	}
+	return string(cs)
+}
 ```
 
 ### **...**

solution/0800-0899/0848.Shifting Letters/README_EN.md

@@ -52,13 +52,88 @@ After shifting the first 3 letters of s by 9, we have "rpl", the answe
 ### **Python3**
 
 ```python
+class Solution:
+    def shiftingLetters(self, s: str, shifts: List[int]) -> str:
+        n = len(s)
+        d = [0] * (n + 1)
+        for i, c in enumerate(s):
+            v = ord(c) - ord('a')
+            d[i] += v
+            d[i + 1] -= v
+        for i, x in enumerate(shifts):
+            d[0] += x
+            d[i + 1] -= x
+        t = 0
+        ans = []
+        for i in range(n):
+            d[i] %= 26
+            ans.append(ascii_lowercase[d[i]])
+            d[i + 1] += d[i]
+        return ''.join(ans)
+```
 
+```python
+class Solution:
+    def shiftingLetters(self, s: str, shifts: List[int]) -> str:
+        n, t = len(s), 0
+        s = list(s)
+        for i in range(n - 1, -1, -1):
+            t += shifts[i]
+            j = (ord(s[i]) - ord('a') + t) % 26
+            s[i] = ascii_lowercase[j]
+        return ''.join(s)
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public String shiftingLetters(String s, int[] shifts) {
+        char[] cs = s.toCharArray();
+        int n = cs.length;
+        long t = 0;
+        for (int i = n - 1; i >= 0; --i) {
+            t += shifts[i];
+            int j = (int) ((cs[i] - 'a' + t) % 26);
+            cs[i] = (char) ('a' + j);
+        }
+        return String.valueOf(cs);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    string shiftingLetters(string s, vector<int>& shifts) {
+        long long t = 0;
+        int n = s.size();
+        for (int i = n - 1; ~i; --i) {
+            t += shifts[i];
+            int j = (s[i] - 'a' + t) % 26;
+            s[i] = 'a' + j;
+        }
+        return s;
+    }
+};
+```
 
+### **Go**
+
+```go
+func shiftingLetters(s string, shifts []int) string {
+	t := 0
+	n := len(s)
+	cs := []byte(s)
+	for i := n - 1; i >= 0; i-- {
+		t += shifts[i]
+		j := (int(cs[i]-'a') + t) % 26
+		cs[i] = byte('a' + j)
+	}
+	return string(cs)
+}
 ```
 
 ### **...**

solution/0800-0899/0848.Shifting Letters/Solution.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    string shiftingLetters(string s, vector<int>& shifts) {
+        long long t = 0;
+        int n = s.size();
+        for (int i = n - 1; ~i; --i) {
+            t += shifts[i];
+            int j = (s[i] - 'a' + t) % 26;
+            s[i] = 'a' + j;
+        }
+        return s;
+    }
+};

solution/0800-0899/0848.Shifting Letters/Solution.go

@@ -0,0 +1,11 @@
+func shiftingLetters(s string, shifts []int) string {
+	t := 0
+	n := len(s)
+	cs := []byte(s)
+	for i := n - 1; i >= 0; i-- {
+		t += shifts[i]
+		j := (int(cs[i]-'a') + t) % 26
+		cs[i] = byte('a' + j)
+	}
+	return string(cs)
+}

solution/0800-0899/0848.Shifting Letters/Solution.java

@@ -0,0 +1,13 @@
+class Solution {
+    public String shiftingLetters(String s, int[] shifts) {
+        char[] cs = s.toCharArray();
+        int n = cs.length;
+        long t = 0;
+        for (int i = n - 1; i >= 0; --i) {
+            t += shifts[i];
+            int j = (int) ((cs[i] - 'a' + t) % 26);
+            cs[i] = (char) ('a' + j);
+        }
+        return String.valueOf(cs);
+    }
+}

solution/0800-0899/0848.Shifting Letters/Solution.py

@@ -1,13 +1,9 @@
 class Solution:
-    def shiftingLetters(self, S, shifts):
-        """
-        :type S: str
-        :type shifts: List[int]
-        :rtype: str
-        """
-        mov = 0
-        ans = list(S)
-        for i in range(len(S) - 1, -1, -1):
-            mov += shifts[i]
-            ans[i] = chr((ord(S[i]) - 97 + mov % 26) % 26 + 97)
-        return ''.join(ans)
+    def shiftingLetters(self, s: str, shifts: List[int]) -> str:
+        n, t = len(s), 0
+        s = list(s)
+        for i in range(n - 1, -1, -1):
+            t += shifts[i]
+            j = (ord(s[i]) - ord('a') + t) % 26
+            s[i] = ascii_lowercase[j]
+        return ''.join(s)