feat: add solutions to lc problem: No.0899

No.0899.Orderly Queue

Author: yanglbme

solution/0800-0899/0899.Orderly Queue/README.md

@@ -45,22 +45,100 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**前言**
+
+对于任何字符串，如果可以交换任意相邻字符，则可以对字符串中的字符做类似冒泡排序的操作，最终得到一个升序排列的字符串。
+
+**方法一：分类判断**
+
+若 $k=1$，我们每次只能将字符串首字符移动到字符串末尾，总共有 $s.length$ 种不同的状态，我们返回其中字典序最小的字符串即可。
+
+若 $k\gt1$，对于形如 $abc[xy]def$ 的字符串，可以依次将 $a$, $b$, $c$ 移动到最后，得到 $[xy]defabc$，然后将 $y$, $x$ 移动到最后，得到 $defabc[yx]$，最后将 $d$, $e$, $f$ 移动到最后，得到 $abc[yx]def$，这样就实现了对 $y$, $x$ 的交换。
+
+因此，只要 $k\gt1$，我们就能够交换字符串中的任何两个相邻字符，最终得到一个升序排列的字符串。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def orderlyQueue(self, s: str, k: int) -> str:
+        if k == 1:
+            ans = s
+            for _ in range(len(s) - 1):
+                s = s[1:] + s[0]
+                ans = min(ans, s)
+            return ans
+        return "".join(sorted(s))
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public String orderlyQueue(String s, int k) {
+        if (k == 1) {
+            String ans = s;
+            StringBuilder sb = new StringBuilder(s);
+            for (int i = 0; i < s.length() - 1; ++i) {
+                sb.append(sb.charAt(0)).deleteCharAt(0);
+                if (sb.toString().compareTo(ans) < 0) {
+                    ans = sb.toString();
+                }
+            }
+            return ans;
+        }
+        char[] cs = s.toCharArray();
+        Arrays.sort(cs);
+        return String.valueOf(cs);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    string orderlyQueue(string s, int k) {
+        if (k == 1) {
+            string ans = s;
+            for (int i = 0; i < s.size() - 1; ++i)
+            {
+                s = s.substr(1) + s[0];
+                if (s < ans) ans = s;
+            }
+            return ans;
+        }
+        sort(s.begin(), s.end());
+        return s;
+    }
+};
+```
 
+### **Go**
+
+```go
+func orderlyQueue(s string, k int) string {
+	if k == 1 {
+		ans := s
+		for i := 0; i < len(s)-1; i++ {
+			s = s[1:] + s[:1]
+			if s < ans {
+				ans = s
+			}
+		}
+		return ans
+	}
+	t := []byte(s)
+	sort.Slice(t, func(i, j int) bool { return t[i] < t[j] })
+	return string(t)
+}
 ```
 
 ### **...**

solution/0800-0899/0899.Orderly Queue/README_EN.md

@@ -44,13 +44,79 @@ In the second move, we move the 3<sup>rd</sup> character &#39;c&#39; to the end,
 ### **Python3**
 
 ```python
-
+class Solution:
+    def orderlyQueue(self, s: str, k: int) -> str:
+        if k == 1:
+            ans = s
+            for _ in range(len(s) - 1):
+                s = s[1:] + s[0]
+                ans = min(ans, s)
+            return ans
+        return "".join(sorted(s))
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public String orderlyQueue(String s, int k) {
+        if (k == 1) {
+            String ans = s;
+            StringBuilder sb = new StringBuilder(s);
+            for (int i = 0; i < s.length() - 1; ++i) {
+                sb.append(sb.charAt(0)).deleteCharAt(0);
+                if (sb.toString().compareTo(ans) < 0) {
+                    ans = sb.toString();
+                }
+            }
+            return ans;
+        }
+        char[] cs = s.toCharArray();
+        Arrays.sort(cs);
+        return String.valueOf(cs);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    string orderlyQueue(string s, int k) {
+        if (k == 1) {
+            string ans = s;
+            for (int i = 0; i < s.size() - 1; ++i)
+            {
+                s = s.substr(1) + s[0];
+                if (s < ans) ans = s;
+            }
+            return ans;
+        }
+        sort(s.begin(), s.end());
+        return s;
+    }
+};
+```
 
+### **Go**
+
+```go
+func orderlyQueue(s string, k int) string {
+	if k == 1 {
+		ans := s
+		for i := 0; i < len(s)-1; i++ {
+			s = s[1:] + s[:1]
+			if s < ans {
+				ans = s
+			}
+		}
+		return ans
+	}
+	t := []byte(s)
+	sort.Slice(t, func(i, j int) bool { return t[i] < t[j] })
+	return string(t)
+}
 ```
 
 ### **...**

solution/0800-0899/0899.Orderly Queue/Solutioin.java

@@ -0,0 +1,18 @@
+class Solution {
+    public String orderlyQueue(String s, int k) {
+        if (k == 1) {
+            String ans = s;
+            StringBuilder sb = new StringBuilder(s);
+            for (int i = 0; i < s.length() - 1; ++i) {
+                sb.append(sb.charAt(0)).deleteCharAt(0);
+                if (sb.toString().compareTo(ans) < 0) {
+                    ans = sb.toString();
+                }
+            }
+            return ans;
+        }
+        char[] cs = s.toCharArray();
+        Arrays.sort(cs);
+        return String.valueOf(cs);
+    }
+}

solution/0800-0899/0899.Orderly Queue/Solution.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    string orderlyQueue(string s, int k) {
+        if (k == 1) {
+            string ans = s;
+            for (int i = 0; i < s.size() - 1; ++i)
+            {
+                s = s.substr(1) + s[0];
+                if (s < ans) ans = s;
+            }
+            return ans;
+        }
+        sort(s.begin(), s.end());
+        return s;
+    }
+};

solution/0800-0899/0899.Orderly Queue/Solution.go

@@ -0,0 +1,15 @@
+func orderlyQueue(s string, k int) string {
+	if k == 1 {
+		ans := s
+		for i := 0; i < len(s)-1; i++ {
+			s = s[1:] + s[:1]
+			if s < ans {
+				ans = s
+			}
+		}
+		return ans
+	}
+	t := []byte(s)
+	sort.Slice(t, func(i, j int) bool { return t[i] < t[j] })
+	return string(t)
+}

solution/0800-0899/0899.Orderly Queue/Solution.py

@@ -0,0 +1,9 @@
+class Solution:
+    def orderlyQueue(self, s: str, k: int) -> str:
+        if k == 1:
+            ans = s
+            for _ in range(len(s) - 1):
+                s = s[1:] + s[0]
+                ans = min(ans, s)
+            return ans
+        return "".join(sorted(s))