feat: add solutions to lc problems: No.3178,3179 (doocs#3082)

Author: yanglbme

solution/3100-3199/3178.Find the Child Who Has the Ball After K Seconds/README.md

@@ -158,32 +158,74 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3178.Fi
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：数学
+
+我们注意到，每一轮有 $n - 1$ 次传递，因此我们可以将 $k$ 对 $n - 1$ 取模，得到 $k$ 在当前轮的传递次数 $mod$，然后我们将 $k$ 除以 $n - 1$，得到当前的轮数 $k$。
+
+接下来我们判断当前的轮数 $k$：
+
+-   如果 $k$ 为奇数，那么当前的传递方向是从队尾到队首，因此会传递到编号为 $n - mod - 1$ 的人手中；
+-   如果 $k$ 为偶数，那么当前的传递方向是从队首到队尾，因此会传递到编号为 $mod$ 的人手中。
+
+时间复杂度 $O(1)$，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def numberOfChild(self, n: int, k: int) -> int:
+        k, mod = divmod(k, n - 1)
+        return n - mod - 1 if k & 1 else mod
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int numberOfChild(int n, int k) {
+        int mod = k % (n - 1);
+        k /= (n - 1);
+        return k % 2 == 1 ? n - mod - 1 : mod;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int numberOfChild(int n, int k) {
+        int mod = k % (n - 1);
+        k /= (n - 1);
+        return k % 2 == 1 ? n - mod - 1 : mod;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func numberOfChild(n int, k int) int {
+	mod := k % (n - 1)
+	k /= (n - 1)
+	if k%2 == 1 {
+		return n - mod - 1
+	}
+	return mod
+}
+```
+
+#### TypeScript
 
+```ts
+function numberOfChild(n: number, k: number): number {
+    const mod = k % (n - 1);
+    k = (k / (n - 1)) | 0;
+    return k % 2 ? n - mod - 1 : mod;
+}
 ```
 
 <!-- tabs:end -->

solution/3100-3199/3178.Find the Child Who Has the Ball After K Seconds/README_EN.md

@@ -156,32 +156,74 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3178.Fi
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Mathematics
+
+We notice that there are $n - 1$ passes in each round. Therefore, we can take $k$ modulo $n - 1$ to get the number of passes $mod$ in the current round. Then we divide $k$ by $n - 1$ to get the current round number $k$.
+
+Next, we judge the current round number $k$:
+
+-   If $k$ is odd, then the current passing direction is from the end of the queue to the head, so it will be passed to the person with the number $n - mod - 1$.
+-   If $k$ is even, then the current passing direction is from the head of the queue to the end, so it will be passed to the person with the number $mod$.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def numberOfChild(self, n: int, k: int) -> int:
+        k, mod = divmod(k, n - 1)
+        return n - mod - 1 if k & 1 else mod
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int numberOfChild(int n, int k) {
+        int mod = k % (n - 1);
+        k /= (n - 1);
+        return k % 2 == 1 ? n - mod - 1 : mod;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int numberOfChild(int n, int k) {
+        int mod = k % (n - 1);
+        k /= (n - 1);
+        return k % 2 == 1 ? n - mod - 1 : mod;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func numberOfChild(n int, k int) int {
+	mod := k % (n - 1)
+	k /= (n - 1)
+	if k%2 == 1 {
+		return n - mod - 1
+	}
+	return mod
+}
+```
+
+#### TypeScript
 
+```ts
+function numberOfChild(n: number, k: number): number {
+    const mod = k % (n - 1);
+    k = (k / (n - 1)) | 0;
+    return k % 2 ? n - mod - 1 : mod;
+}
 ```
 
 <!-- tabs:end -->

solution/3100-3199/3178.Find the Child Who Has the Ball After K Seconds/Solution.cpp

@@ -0,0 +1,8 @@
+class Solution {
+public:
+    int numberOfChild(int n, int k) {
+        int mod = k % (n - 1);
+        k /= (n - 1);
+        return k % 2 == 1 ? n - mod - 1 : mod;
+    }
+};

solution/3100-3199/3178.Find the Child Who Has the Ball After K Seconds/Solution.go

@@ -0,0 +1,8 @@
+func numberOfChild(n int, k int) int {
+	mod := k % (n - 1)
+	k /= (n - 1)
+	if k%2 == 1 {
+		return n - mod - 1
+	}
+	return mod
+}

solution/3100-3199/3178.Find the Child Who Has the Ball After K Seconds/Solution.java

@@ -0,0 +1,7 @@
+class Solution {
+    public int numberOfChild(int n, int k) {
+        int mod = k % (n - 1);
+        k /= (n - 1);
+        return k % 2 == 1 ? n - mod - 1 : mod;
+    }
+}

solution/3100-3199/3178.Find the Child Who Has the Ball After K Seconds/Solution.py

@@ -0,0 +1,4 @@
+class Solution:
+    def numberOfChild(self, n: int, k: int) -> int:
+        k, mod = divmod(k, n - 1)
+        return n - mod - 1 if k & 1 else mod

solution/3100-3199/3178.Find the Child Who Has the Ball After K Seconds/Solution.ts

@@ -0,0 +1,5 @@
+function numberOfChild(n: number, k: number): number {
+    const mod = k % (n - 1);
+    k = (k / (n - 1)) | 0;
+    return k % 2 ? n - mod - 1 : mod;
+}

solution/3100-3199/3179.Find the N-th Value After K Seconds/README.md

@@ -116,32 +116,98 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3100-3199/3179.Fi
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：模拟
+
+我们注意到，整数 $n$ 的范围是 $1 \leq n \leq 1000$，因此我们可以直接模拟这个过程。
+
+我们定义一个长度为 $n$ 的数组 $a$，并初始化所有元素为 $1$。然后我们模拟 $k$ 秒的过程，每一秒我们都更新数组 $a$ 的元素，直到 $k$ 秒结束。
+
+最后，我们返回 $a[n - 1]$ 即可。
+
+时间复杂度 $O(n \times k)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $a$ 的长度。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+class Solution:
+    def valueAfterKSeconds(self, n: int, k: int) -> int:
+        a = [1] * n
+        mod = 10**9 + 7
+        for _ in range(k):
+            for i in range(1, n):
+                a[i] = (a[i] + a[i - 1]) % mod
+        return a[n - 1]
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int valueAfterKSeconds(int n, int k) {
+        final int mod = (int) 1e9 + 7;
+        int[] a = new int[n];
+        Arrays.fill(a, 1);
+        while (k-- > 0) {
+            for (int i = 1; i < n; ++i) {
+                a[i] = (a[i] + a[i - 1]) % mod;
+            }
+        }
+        return a[n - 1];
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int valueAfterKSeconds(int n, int k) {
+        const int mod = 1e9 + 7;
+        vector<int> a(n, 1);
+        while (k-- > 0) {
+            for (int i = 1; i < n; ++i) {
+                a[i] = (a[i] + a[i - 1]) % mod;
+            }
+        }
+        return a[n - 1];
+    }
+};
 ```
 
 #### Go
 
 ```go
+func valueAfterKSeconds(n int, k int) int {
+	const mod int = 1e9 + 7
+	a := make([]int, n)
+	for i := range a {
+		a[i] = 1
+	}
+	for ; k > 0; k-- {
+		for i := 1; i < n; i++ {
+			a[i] = (a[i] + a[i-1]) % mod
+		}
+	}
+	return a[n-1]
+}
+```
 
+#### TypeScript
+
+```ts
+function valueAfterKSeconds(n: number, k: number): number {
+    const a: number[] = Array(n).fill(1);
+    const mod: number = 10 ** 9 + 7;
+    while (k--) {
+        for (let i = 1; i < n; ++i) {
+            a[i] = (a[i] + a[i - 1]) % mod;
+        }
+    }
+    return a[n - 1];
+}
 ```
 
 <!-- tabs:end -->