Merge pull request #1347 from 0xff-dev/1625

Add solution and test-cases for problem 1625

Author: 6boris

leetcode/1601-1700/1625.Lexicographically-Smallest-String-After-Applying-Operations/README.md

@@ -1,28 +1,55 @@
 # [1625.Lexicographically Smallest String After Applying Operations][title]
 
-> [!WARNING|style:flat]
-> This question is temporarily unanswered if you have good ideas. Welcome to [Create Pull Request PR](https://github.com/kylesliu/awesome-golang-algorithm)
-
 ## Description
+You are given a string `s` of **even length** consisting of digits from `0` to `9`, and two integers `a` and `b`.
+
+You can apply either of the following two operations any number of times and in any order on `s`:
+
+- Add `a` to all odd indices of `s` (**0-indexed**). Digits post `9` are cycled back to `0`. For example, if `s = "3456"` and `a = 5`, `s` becomes `"3951"`.
+- Rotate `s` to the right by `b` positions. For example, if `s = "3456"` and `b = 1`, s becomes `"6345"`.
+
+Return the **lexicographically smallest** string you can obtain by applying the above operations any number of times on s.
+
+A string `a` is lexicographically smaller than a string `b` (of the same length) if in the first position where `a` and `b` differ, string a has `a` letter that appears earlier in the alphabet than the corresponding letter in `b`. For example, `"0158"` is lexicographically smaller than `"0190"` because the first position they differ is at the third letter, and `'5'` comes before `'9'`.
 
 **Example 1:**
 
 ```
-Input: a = "11", b = "1"
-Output: "100"
+Input: s = "5525", a = 9, b = 2
+Output: "2050"
+Explanation: We can apply the following operations:
+Start:  "5525"
+Rotate: "2555"
+Add:    "2454"
+Add:    "2353"
+Rotate: "5323"
+Add:    "5222"
+Add:    "5121"
+Rotate: "2151"
+Add:    "2050"
+There is no way to obtain a string that is lexicographically smaller than "2050".
 ```
 
-## 题意
-> ...
+**Example 2:**
 
-## 题解
-
-### 思路1
-> ...
-Lexicographically Smallest String After Applying Operations
-```go
 ```
+Input: s = "74", a = 5, b = 1
+Output: "24"
+Explanation: We can apply the following operations:
+Start:  "74"
+Rotate: "47"
+Add:    "42"
+Rotate: "24"
+There is no way to obtain a string that is lexicographically smaller than "24".
+```
+
+**Example 3:**
 
+```
+Input: s = "0011", a = 4, b = 2
+Output: "0011"
+Explanation: There are no sequence of operations that will give us a lexicographically smaller string than "0011".
+```
 
 ## 结语
 

leetcode/1601-1700/1625.Lexicographically-Smallest-String-After-Applying-Operations/Solution.go

@@ -1,5 +1,32 @@
 package Solution
 
-func Solution(x bool) bool {
-	return x
+func Solution(s string, a int, b int) string {
+	n := len(s)
+	vis := make([]bool, n)
+	res := s
+	s = s + s
+	for i := 0; !vis[i]; i = (i + b) % n {
+		vis[i] = true
+		for j := 0; j < 10; j++ {
+			kLimit := 0
+			if b%2 != 0 {
+				kLimit = 9
+			}
+			for k := 0; k <= kLimit; k++ {
+				// before each accumulation, re-truncate t
+				t := []byte(s[i : i+n])
+				for p := 1; p < n; p += 2 {
+					t[p] = '0' + byte((int(t[p]-'0')+j*a)%10)
+				}
+				for p := 0; p < n; p += 2 {
+					t[p] = '0' + byte((int(t[p]-'0')+k*a)%10)
+				}
+				tStr := string(t)
+				if tStr < res {
+					res = tStr
+				}
+			}
+		}
+	}
+	return res
 }

leetcode/1601-1700/1625.Lexicographically-Smallest-String-After-Applying-Operations/Solution_test.go

@@ -10,30 +10,31 @@ func TestSolution(t *testing.T) {
 	//	测试用例
 	cases := []struct {
 		name   string
-		inputs bool
-		expect bool
+		s      string
+		a, b   int
+		expect string
 	}{
-		{"TestCase", true, true},
-		{"TestCase", true, true},
-		{"TestCase", false, false},
+		{"TestCase1", "5525", 9, 2, "2050"},
+		{"TestCase2", "74", 5, 1, "24"},
+		{"TestCase3", "0011", 4, 2, "0011"},
 	}
 
 	//	开始测试
 	for i, c := range cases {
 		t.Run(c.name+" "+strconv.Itoa(i), func(t *testing.T) {
-			got := Solution(c.inputs)
+			got := Solution(c.s, c.a, c.b)
 			if !reflect.DeepEqual(got, c.expect) {
-				t.Fatalf("expected: %v, but got: %v, with inputs: %v",
-					c.expect, got, c.inputs)
+				t.Fatalf("expected: %v, but got: %v, with inputs: %v %v %v",
+					c.expect, got, c.s, c.a, c.b)
 			}
 		})
 	}
 }
 
-//	压力测试
+// 压力测试
 func BenchmarkSolution(b *testing.B) {
 }
 
-//	使用案列
+// 使用案列
 func ExampleSolution() {
 }