| comments | difficulty | edit_url | rating | source | tags | ||
|---|---|---|---|---|---|---|---|
true |
Medium |
1992 |
Weekly Contest 211 Q2 |
|
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
ato all odd indices ofs(0-indexed). Digits post9are cycled back to0. For example, ifs = "3456"anda = 5,sbecomes"3951". - Rotate
sto the right bybpositions. For example, ifs = "3456"andb = 1,sbecomes"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: 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:
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".
Constraints:
2 <= s.length <= 100s.lengthis even.sconsists of digits from0to9only.1 <= a <= 91 <= b <= s.length - 1
class Solution:
def findLexSmallestString(self, s: str, a: int, b: int) -> str:
q = deque([s])
vis = {s}
ans = s
while q:
s = q.popleft()
if ans > s:
ans = s
t1 = ''.join(
[str((int(c) + a) % 10) if i & 1 else c for i, c in enumerate(s)]
)
t2 = s[-b:] + s[:-b]
for t in (t1, t2):
if t not in vis:
vis.add(t)
q.append(t)
return ansclass Solution {
public String findLexSmallestString(String s, int a, int b) {
Deque<String> q = new ArrayDeque<>();
q.offer(s);
Set<String> vis = new HashSet<>();
vis.add(s);
String ans = s;
int n = s.length();
while (!q.isEmpty()) {
s = q.poll();
if (ans.compareTo(s) > 0) {
ans = s;
}
char[] cs = s.toCharArray();
for (int i = 1; i < n; i += 2) {
cs[i] = (char) (((cs[i] - '0' + a) % 10) + '0');
}
String t1 = String.valueOf(cs);
String t2 = s.substring(n - b) + s.substring(0, n - b);
for (String t : List.of(t1, t2)) {
if (vis.add(t)) {
q.offer(t);
}
}
}
return ans;
}
}class Solution {
public:
string findLexSmallestString(string s, int a, int b) {
queue<string> q{{s}};
unordered_set<string> vis{{s}};
string ans = s;
int n = s.size();
while (!q.empty()) {
s = q.front();
q.pop();
ans = min(ans, s);
string t1 = s;
for (int i = 1; i < n; i += 2) {
t1[i] = (t1[i] - '0' + a) % 10 + '0';
}
string t2 = s.substr(n - b) + s.substr(0, n - b);
for (auto& t : {t1, t2}) {
if (!vis.count(t)) {
vis.insert(t);
q.emplace(t);
}
}
}
return ans;
}
};func findLexSmallestString(s string, a int, b int) string {
q := []string{s}
vis := map[string]bool{s: true}
ans := s
n := len(s)
for len(q) > 0 {
s = q[0]
q = q[1:]
if ans > s {
ans = s
}
t1 := []byte(s)
for i := 1; i < n; i += 2 {
t1[i] = byte((int(t1[i]-'0')+a)%10 + '0')
}
t2 := s[n-b:] + s[:n-b]
for _, t := range []string{string(t1), t2} {
if !vis[t] {
vis[t] = true
q = append(q, t)
}
}
}
return ans
}class Solution:
def findLexSmallestString(self, s: str, a: int, b: int) -> str:
ans = s
n = len(s)
s = list(s)
for _ in range(n):
s = s[-b:] + s[:-b]
for j in range(10):
for k in range(1, n, 2):
s[k] = str((int(s[k]) + a) % 10)
if b & 1:
for p in range(10):
for k in range(0, n, 2):
s[k] = str((int(s[k]) + a) % 10)
t = ''.join(s)
if ans > t:
ans = t
else:
t = ''.join(s)
if ans > t:
ans = t
return ansclass Solution {
public String findLexSmallestString(String s, int a, int b) {
int n = s.length();
String ans = s;
for (int i = 0; i < n; ++i) {
s = s.substring(b) + s.substring(0, b);
char[] cs = s.toCharArray();
for (int j = 0; j < 10; ++j) {
for (int k = 1; k < n; k += 2) {
cs[k] = (char) (((cs[k] - '0' + a) % 10) + '0');
}
if ((b & 1) == 1) {
for (int p = 0; p < 10; ++p) {
for (int k = 0; k < n; k += 2) {
cs[k] = (char) (((cs[k] - '0' + a) % 10) + '0');
}
s = String.valueOf(cs);
if (ans.compareTo(s) > 0) {
ans = s;
}
}
} else {
s = String.valueOf(cs);
if (ans.compareTo(s) > 0) {
ans = s;
}
}
}
}
return ans;
}
}class Solution {
public:
string findLexSmallestString(string s, int a, int b) {
int n = s.size();
string ans = s;
for (int i = 0; i < n; ++i) {
s = s.substr(n - b) + s.substr(0, n - b);
for (int j = 0; j < 10; ++j) {
for (int k = 1; k < n; k += 2) {
s[k] = (s[k] - '0' + a) % 10 + '0';
}
if (b & 1) {
for (int p = 0; p < 10; ++p) {
for (int k = 0; k < n; k += 2) {
s[k] = (s[k] - '0' + a) % 10 + '0';
}
ans = min(ans, s);
}
} else {
ans = min(ans, s);
}
}
}
return ans;
}
};func findLexSmallestString(s string, a int, b int) string {
n := len(s)
ans := s
for _ = range s {
s = s[n-b:] + s[:n-b]
cs := []byte(s)
for j := 0; j < 10; j++ {
for k := 1; k < n; k += 2 {
cs[k] = byte((int(cs[k]-'0')+a)%10 + '0')
}
if b&1 == 1 {
for p := 0; p < 10; p++ {
for k := 0; k < n; k += 2 {
cs[k] = byte((int(cs[k]-'0')+a)%10 + '0')
}
s = string(cs)
if ans > s {
ans = s
}
}
} else {
s = string(cs)
if ans > s {
ans = s
}
}
}
}
return ans
}