From 988d90b044b275b64a9313da4240acbdc72eda72 Mon Sep 17 00:00:00 2001 From: 0xff-dev Date: Sun, 19 Oct 2025 19:31:58 +0800 Subject: [PATCH] Add solution and test-cases for problem 1625 --- .../README.md | 53 ++++++++++++++----- .../Solution.go | 31 ++++++++++- .../Solution_test.go | 21 ++++---- 3 files changed, 80 insertions(+), 25 deletions(-) diff --git a/leetcode/1601-1700/1625.Lexicographically-Smallest-String-After-Applying-Operations/README.md b/leetcode/1601-1700/1625.Lexicographically-Smallest-String-After-Applying-Operations/README.md index 39d786f4a..a69d3a8b6 100755 --- a/leetcode/1601-1700/1625.Lexicographically-Smallest-String-After-Applying-Operations/README.md +++ b/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". +``` ## 结语 diff --git a/leetcode/1601-1700/1625.Lexicographically-Smallest-String-After-Applying-Operations/Solution.go b/leetcode/1601-1700/1625.Lexicographically-Smallest-String-After-Applying-Operations/Solution.go index d115ccf5e..2aefd12cd 100644 --- a/leetcode/1601-1700/1625.Lexicographically-Smallest-String-After-Applying-Operations/Solution.go +++ b/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 } diff --git a/leetcode/1601-1700/1625.Lexicographically-Smallest-String-After-Applying-Operations/Solution_test.go b/leetcode/1601-1700/1625.Lexicographically-Smallest-String-After-Applying-Operations/Solution_test.go index 14ff50eb4..282b4bc75 100644 --- a/leetcode/1601-1700/1625.Lexicographically-Smallest-String-After-Applying-Operations/Solution_test.go +++ b/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() { }