2381. Shifting Letters II

You are given a string s of lowercase English letters and a 2D integer array shifts where shifts[i] = [starti, endi, directioni]. For every i, shift the characters in s from the index starti to the index endi (inclusive) forward if directioni = 1, or shift the characters backward if directioni = 0.

Shifting a character forward means replacing it with the next letter in the alphabet (wrapping around so that 'z' becomes 'a'). Similarly, shifting a character backward means replacing it with the previous letter in the alphabet (wrapping around so that 'a' becomes 'z').

Return the final string after all such shifts to s are applied.

 Example 1:

Input: s = "abc", shifts = [[0,1,0],[1,2,1],[0,2,1]]
Output: "ace"
Explanation: Firstly, shift the characters from index 0 to index 1 backward. Now s = "zac".
Secondly, shift the characters from index 1 to index 2 forward. Now s = "zbd".
Finally, shift the characters from index 0 to index 2 forward. Now s = "ace".

Example 2:

Input: s = "dztz", shifts = [[0,0,0],[1,1,1]]
Output: "catz"
Explanation: Firstly, shift the characters from index 0 to index 0 backward. Now s = "cztz".
Finally, shift the characters from index 1 to index 1 forward. Now s = "catz".

 Constraints:

• 1 <= s.length, shifts.length <= 5 * 104
• shifts[i].length == 3
• 0 <= starti <= endi < s.length
• 0 <= directioni <= 1
• s consists of lowercase English letters.

C++

• class Solution {
  public:
      string shiftingLetters(string s, vector<vector<int>>& shifts) {
          int n = s.size();
          vector<int> d(n + 1);
          for (auto& e : shifts) {
              if (e[2] == 0) {
                  e[2]--;
              }
              d[e[0]] += e[2];
              d[e[1] + 1] -= e[2];
          }
          for (int i = 1; i <= n; ++i) {
              d[i] += d[i - 1];
          }
          string ans;
          for (int i = 0; i < n; ++i) {
              int j = (s[i] - 'a' + d[i] % 26 + 26) % 26;
              ans += ('a' + j);
          }
          return ans;
      }
  };

JAVA

• class Solution {
      public String shiftingLetters(String s, int[][] shifts) {
          int n = s.length();
          int[] d = new int[n + 1];
          for (int[] e : shifts) {
              if (e[2] == 0) {
                  e[2]--;
              }
              d[e[0]] += e[2];
              d[e[1] + 1] -= e[2];
          }
          for (int i = 1; i <= n; ++i) {
              d[i] += d[i - 1];
          }
          StringBuilder ans = new StringBuilder();
          for (int i = 0; i < n; ++i) {
              int j = (s.charAt(i) - 'a' + d[i] % 26 + 26) % 26;
              ans.append((char) ('a' + j));
          }
          return ans.toString();
      }
  }

PYTHON

• class Solution:
      def shiftingLetters(self, s: str, shifts: list) -> str:
          n = len(s)
          d = [0] * (n + 1)
          
          for e in shifts:
              if e[2] == 0:
                  e[2] -= 1
              d[e[0]] += e[2]
              d[e[1] + 1] -= e[2]
          
          for i in range(1, n + 1):
              d[i] += d[i - 1]
          
          ans = []
          for i in range(n):
              j = (ord(s[i]) - ord('a') + d[i] % 26 + 26) % 26
              ans.append(chr(ord('a') + j))
          
          return ''.join(ans)