feat: add solutions to lc problem: No.0779

No.0779.K-th Symbol in Grammar

Author: yanglbme

solution/0700-0799/0779.K-th Symbol in Grammar/README.md

@@ -77,6 +77,39 @@ n = 5: 0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。
 
+**方法二：位运算 + 脑筋急转弯**
+
+题目中索引从 $1$ 开始，我们将 $k$ 改成 $k-1$，将索引转换为从 $0$ 开始。在接下来的讨论中，索引均从 $0$ 开始。
+
+仔细观察，一行中的第 $i$ 个字符，会在第 $2i$ 和第 $2i+1$ 个位置产生两个字符。
+
+```
+0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0
+```
+
+如果第 $i$ 个字符是 $0$，那么在位置 $2i$ 和 $2i+1$ 产生的字符分别是 $0$ 和 $1$；如果第 $i$ 个字符是 $1$，产生的字符是 $1$ 和 $0$。
+
+```
+0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0
+      ^     * *
+```
+
+```
+0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0
+        ^       * *
+```
+
+可以发现，第 $2i$ （偶数位）个字符总是和第 $i$ 个字符相同，而第 $2i+1$ （奇数位）个字符是第 $i$ 个字符的反转。也就是说，奇数位上的字符总是发生了一次反转而来的。反转偶数次，字符不变；反转奇数次，相当于反转了一次。
+
+因此，我们只需要看 $k$ 这个数字是否是奇数，若是，累计一次反转。然后将 $k$ 除以 $2$，继续判断，并累计反转次数，直至 $k$ 为 $0$。
+
+最后判断反转的次数是否为奇数，是则答案为 $1$，否则为 $0$。
+
+以上累计反转次数的过程，实际上等价于求 $k$ 的二进制表示中，有多少位是 $1$。
+
+时间复杂度 $O(\log k)$，空间复杂度 $O(1)$。
+
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -93,6 +126,12 @@ class Solution:
         return self.kthGrammar(n - 1, k - (1 << (n - 2))) ^ 1
 ```
 
+```python
+class Solution:
+    def kthGrammar(self, n: int, k: int) -> int:
+        return (k - 1).bit_count() & 1
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -111,6 +150,15 @@ class Solution {
 }
 ```
 
+
+```java
+class Solution {
+    public int kthGrammar(int n, int k) {
+        return Integer.bitCount(k - 1) & 1;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -124,6 +172,15 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int kthGrammar(int n, int k) {
+        return __builtin_popcount(k - 1) & 1;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -138,6 +195,12 @@ func kthGrammar(n int, k int) int {
 }
 ```
 
+```go
+func kthGrammar(n int, k int) int {
+	return bits.OnesCount(uint(k-1)) & 1
+}
+```
+
 ### **...**
 
 ```

solution/0700-0799/0779.K-th Symbol in Grammar/README_EN.md

@@ -65,6 +65,12 @@ class Solution:
         return self.kthGrammar(n - 1, k - (1 << (n - 2))) ^ 1
 ```
 
+```python
+class Solution:
+    def kthGrammar(self, n: int, k: int) -> int:
+        return (k - 1).bit_count() & 1
+```
+
 ### **Java**
 
 ```java
@@ -81,6 +87,14 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int kthGrammar(int n, int k) {
+        return Integer.bitCount(k - 1) & 1;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -94,6 +108,15 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int kthGrammar(int n, int k) {
+        return __builtin_popcount(k - 1) & 1;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -108,6 +131,12 @@ func kthGrammar(n int, k int) int {
 }
 ```
 
+```go
+func kthGrammar(n int, k int) int {
+	return bits.OnesCount(uint(k-1)) & 1
+}
+```
+
 ### **...**
 
 ```

solution/0700-0799/0779.K-th Symbol in Grammar/Solution.cpp

@@ -1,8 +1,6 @@
 class Solution {
 public:
     int kthGrammar(int n, int k) {
-        if (n == 1) return 0;
-        if (k <= (1 << (n - 2))) return kthGrammar(n - 1, k);
-        return kthGrammar(n - 1, k - (1 << (n - 2))) ^ 1;
+        return __builtin_popcount(k - 1) & 1;
     }
 };

solution/0700-0799/0779.K-th Symbol in Grammar/Solution.go

@@ -1,9 +1,3 @@
 func kthGrammar(n int, k int) int {
-	if n == 1 {
-		return 0
-	}
-	if k <= (1 << (n - 2)) {
-		return kthGrammar(n-1, k)
-	}
-	return kthGrammar(n-1, k-(1<<(n-2))) ^ 1
+	return bits.OnesCount(uint(k-1)) & 1
 }

solution/0700-0799/0779.K-th Symbol in Grammar/Solution.java

@@ -1,11 +1,5 @@
 class Solution {
     public int kthGrammar(int n, int k) {
-        if (n == 1) {
-            return 0;
-        }
-        if (k <= (1 << (n - 2))) {
-            return kthGrammar(n - 1, k);
-        }
-        return kthGrammar(n - 1, k - (1 << (n - 2))) ^ 1;
+        return Integer.bitCount(k - 1) & 1;
     }
 }

solution/0700-0799/0779.K-th Symbol in Grammar/Solution.py

@@ -1,7 +1,3 @@
 class Solution:
     def kthGrammar(self, n: int, k: int) -> int:
-        if n == 1:
-            return 0
-        if k <= (1 << (n - 2)):
-            return self.kthGrammar(n - 1, k)
-        return self.kthGrammar(n - 1, k - (1 << (n - 2))) ^ 1
+        return (k - 1).bit_count() & 1