feat: add solutions to lc problem: No.2490 (doocs#1046)

No.2490.Circular Sentence

Author: yanglbme

solution/2400-2499/2490.Circular Sentence/README.md

@@ -74,10 +74,16 @@
 
 **方法一：模拟**
 
-根据题意模拟即可。
+我们将字符串按照空格分割成单词，然后判断每个单词的最后一个字符和下一个单词的第一个字符是否相等，如果不相等则返回 `false`，否则遍历完所有单词后返回 `true`。
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是字符串的长度。
 
+**方法二：模拟（空间优化）**
+
+我们可以先判断字符串的第一个字符和最后一个字符是否相等，如果不相等则返回 `false`，否则遍历字符串，如果当前字符是空格，则判断前一个字符和后一个字符是否相等，如果不相等则返回 `false`，否则遍历完所有字符后返回 `true`。
+
+时间复杂度 $O(n)$，其中 $n$ 是字符串的长度。空间复杂度 $O(1)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -87,8 +93,17 @@
 ```python
 class Solution:
     def isCircularSentence(self, sentence: str) -> bool:
-        sentence = sentence.split()
-        return all(s[0] == sentence[i - 1][-1] for i, s in enumerate(sentence))
+        ss = sentence.split()
+        n = len(ss)
+        return all(s[-1] == ss[(i + 1) % n][0] for i, s in enumerate(ss))
+```
+
+```python
+class Solution:
+    def isCircularSentence(self, s: str) -> bool:
+        return s[0] == s[-1] and all(
+            c != " " or s[i - 1] == s[i + 1] for i, c in enumerate(s)
+        )
 ```
 
 ### **Java**
@@ -98,12 +113,27 @@ class Solution:
 ```java
 class Solution {
     public boolean isCircularSentence(String sentence) {
-        if (sentence.charAt(0) != sentence.charAt(sentence.length() - 1)) {
+        var ss = sentence.split(" ");
+        int n = ss.length;
+        for (int i = 0; i < n; ++i) {
+            if (ss[i].charAt(ss[i].length() - 1) != ss[(i + 1) % n].charAt(0)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
+```java
+class Solution {
+    public boolean isCircularSentence(String s) {
+        int n = s.length();
+        if (s.charAt(0) != s.charAt(n - 1)) {
             return false;
         }
-        String[] ss = sentence.split(" ");
-        for (int i = 1; i < ss.length; ++i) {
-            if (ss[i].charAt(0) != ss[i - 1].charAt(ss[i - 1].length() - 1)) {
+        for (int i = 1; i < n; ++i) {
+            if (s.charAt(i) == ' ' && s.charAt(i - 1) != s.charAt(i + 1)) {
                 return false;
             }
         }
@@ -118,13 +148,38 @@ class Solution {
 class Solution {
 public:
     bool isCircularSentence(string sentence) {
-        if (sentence[0] != sentence[sentence.size() - 1]) return false;
-        istringstream is(sentence);
-        vector<string> ss;
-        string s;
-        while (is >> s) ss.emplace_back(s);
-        for (int i = 1; i < ss.size(); ++i) {
-            if (ss[i][0] != ss[i - 1][ss[i - 1].size() - 1]) {
+        auto ss = split(sentence, ' ');
+        int n = ss.size();
+        for (int i = 0; i < n; ++i) {
+            if (ss[i].back() != ss[(i + 1) % n][0]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    vector<string> split(string& s, char delim) {
+        stringstream ss(s);
+        string item;
+        vector<string> res;
+        while (getline(ss, item, delim)) {
+            res.emplace_back(item);
+        }
+        return res;
+    }
+};
+```
+
+```cpp
+class Solution {
+public:
+    bool isCircularSentence(string s) {
+        int n = s.size();
+        if (s[0] != s.back()) {
+            return false;
+        }
+        for (int i = 1; i < n; ++i) {
+            if (s[i] == ' ' && s[i - 1] != s[i + 1]) {
                 return false;
             }
         }
@@ -137,12 +192,25 @@ public:
 
 ```go
 func isCircularSentence(sentence string) bool {
-	if sentence[0] != sentence[len(sentence)-1] {
+	ss := strings.Split(sentence, " ")
+	n := len(ss)
+	for i, s := range ss {
+		if s[len(s)-1] != ss[(i+1)%n][0] {
+			return false
+		}
+	}
+	return true
+}
+```
+
+```go
+func isCircularSentence(s string) bool {
+	n := len(s)
+	if s[0] != s[n-1] {
 		return false
 	}
-	ss := strings.Split(sentence, " ")
-	for i := 1; i < len(ss); i++ {
-		if ss[i][0] != ss[i-1][len(ss[i-1])-1] {
+	for i := 1; i < n; i++ {
+		if s[i] == ' ' && s[i-1] != s[i+1] {
 			return false
 		}
 	}
@@ -153,19 +221,38 @@ func isCircularSentence(sentence string) bool {
 ### **JavaScript**
 
 ```js
+/**
+ * @param {string} sentence
+ * @return {boolean}
+ */
 var isCircularSentence = function (sentence) {
-    const words = sentence.split(' ');
-    const post = words[0].charCodeAt(0);
-    let prev = words[0].charCodeAt(words[0].length - 1);
-    const n = words.length;
-    for (let i = 1; i < n; i++) {
-        let cur = words[i];
-        if (cur.charCodeAt(0) !== prev) {
+    const ss = sentence.split(' ');
+    const n = ss.length;
+    for (let i = 0; i < n; ++i) {
+        if (ss[i][ss[i].length - 1] !== ss[(i + 1) % n][0]) {
             return false;
         }
-        prev = cur.charCodeAt(cur.length - 1);
     }
-    return post === prev;
+    return true;
+};
+```
+
+```js
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isCircularSentence = function (s) {
+    const n = s.length;
+    if (s[0] !== s[n - 1]) {
+        return false;
+    }
+    for (let i = 1; i < n; ++i) {
+        if (s[i] === ' ' && s[i - 1] !== s[i + 1]) {
+            return false;
+        }
+    }
+    return true;
 };
 ```
 
@@ -175,11 +262,23 @@ var isCircularSentence = function (sentence) {
 function isCircularSentence(sentence: string): boolean {
     const ss = sentence.split(' ');
     const n = ss.length;
-    if (ss[0][0] !== ss[n - 1][ss[n - 1].length - 1]) {
+    for (let i = 0; i < n; ++i) {
+        if (ss[i][ss[i].length - 1] !== ss[(i + 1) % n][0]) {
+            return false;
+        }
+    }
+    return true;
+}
+```
+
+```ts
+function isCircularSentence(s: string): boolean {
+    const n = s.length;
+    if (s[0] !== s[n - 1]) {
         return false;
     }
-    for (let i = 0; i < n - 1; i++) {
-        if (ss[i][ss[i].length - 1] !== ss[i + 1][0]) {
+    for (let i = 1; i < n; ++i) {
+        if (s[i] === ' ' && s[i - 1] !== s[i + 1]) {
             return false;
         }
     }
@@ -194,11 +293,8 @@ impl Solution {
     pub fn is_circular_sentence(sentence: String) -> bool {
         let ss: Vec<String> = sentence.split(' ').map(String::from).collect();
         let n = ss.len();
-        if ss[0].as_bytes()[0] != ss[n - 1].as_bytes()[ss[n - 1].len() - 1] {
-            return false;
-        }
-        for i in 1..n {
-            if ss[i - 1].as_bytes()[ss[i - 1].len() - 1] != ss[i].as_bytes()[0] {
+        for i in 0..n {
+            if ss[i].as_bytes()[ss[i].len() - 1] != ss[(i + 1) % n].as_bytes()[0] {
                 return false;
             }
         }