feat: add solutions to lc problems: No.2923,2924 (doocs#1933)

* No.2923.Find Champion I
* No.2924.Find Champion II

Author: yanglbme

solution/2900-2999/2923.Find Champion I/README.md

@@ -53,34 +53,106 @@ grid[1][2] == 1 表示 1 队比 2 队强。
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：枚举**
+
+我们可以枚举每一支队伍 $i$，如果 $i$ 队的每一场比赛都赢了，那么 $i$ 队就是冠军，直接返回 $i$ 即可。
+
+时间复杂度 $O(n^2)$，其中 $n$ 是队伍数量。空间复杂度 $O(1)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def findChampion(self, grid: List[List[int]]) -> int:
+        for i, row in enumerate(grid):
+            if all(x == 1 for j, x in enumerate(row) if i != j):
+                return i
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public int findChampion(int[][] grid) {
+        int n = grid.length;
+        for (int i = 0;; ++i) {
+            int cnt = 0;
+            for (int j = 0; j < n; ++j) {
+                if (i != j && grid[i][j] == 1) {
+                    ++cnt;
+                }
+            }
+            if (cnt == n - 1) {
+                return i;
+            }
+        }
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    int findChampion(vector<vector<int>>& grid) {
+        int n = grid.size();
+        for (int i = 0;; ++i) {
+            int cnt = 0;
+            for (int j = 0; j < n; ++j) {
+                if (i != j && grid[i][j] == 1) {
+                    ++cnt;
+                }
+            }
+            if (cnt == n - 1) {
+                return i;
+            }
+        }
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func findChampion(grid [][]int) int {
+	n := len(grid)
+	for i := 0; ; i++ {
+		cnt := 0
+		for j, x := range grid[i] {
+			if i != j && x == 1 {
+				cnt++
+			}
+		}
+		if cnt == n-1 {
+			return i
+		}
+	}
+}
+```
 
+### **TypeScript**
+
+```ts
+function findChampion(grid: number[][]): number {
+    for (let i = 0, n = grid.length; ; ++i) {
+        let cnt = 0;
+        for (let j = 0; j < n; ++j) {
+            if (i !== j && grid[i][j] === 1) {
+                ++cnt;
+            }
+        }
+        if (cnt === n - 1) {
+            return i;
+        }
+    }
+}
 ```
 
 ### **...**

solution/2900-2999/2923.Find Champion I/README_EN.md

@@ -47,30 +47,102 @@ So team 1 will be the champion.
 
 ## Solutions
 
+**Solution 1: Enumeration**
+
+We can enumerate each team $i$. If team $i$ has won every match, then team $i$ is the champion, and we can directly return $i$.
+
+The time complexity is $O(n^2)$, where $n$ is the number of teams. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def findChampion(self, grid: List[List[int]]) -> int:
+        for i, row in enumerate(grid):
+            if all(x == 1 for j, x in enumerate(row) if i != j):
+                return i
 ```
 
 ### **Java**
 
 ```java
-
+class Solution {
+    public int findChampion(int[][] grid) {
+        int n = grid.length;
+        for (int i = 0;; ++i) {
+            int cnt = 0;
+            for (int j = 0; j < n; ++j) {
+                if (i != j && grid[i][j] == 1) {
+                    ++cnt;
+                }
+            }
+            if (cnt == n - 1) {
+                return i;
+            }
+        }
+    }
+}
 ```
 
 ### **C++**
 
 ```cpp
-
+class Solution {
+public:
+    int findChampion(vector<vector<int>>& grid) {
+        int n = grid.size();
+        for (int i = 0;; ++i) {
+            int cnt = 0;
+            for (int j = 0; j < n; ++j) {
+                if (i != j && grid[i][j] == 1) {
+                    ++cnt;
+                }
+            }
+            if (cnt == n - 1) {
+                return i;
+            }
+        }
+    }
+};
 ```
 
 ### **Go**
 
 ```go
+func findChampion(grid [][]int) int {
+	n := len(grid)
+	for i := 0; ; i++ {
+		cnt := 0
+		for j, x := range grid[i] {
+			if i != j && x == 1 {
+				cnt++
+			}
+		}
+		if cnt == n-1 {
+			return i
+		}
+	}
+}
+```
 
+### **TypeScript**
+
+```ts
+function findChampion(grid: number[][]): number {
+    for (let i = 0, n = grid.length; ; ++i) {
+        let cnt = 0;
+        for (let j = 0; j < n; ++j) {
+            if (i !== j && grid[i][j] === 1) {
+                ++cnt;
+            }
+        }
+        if (cnt === n - 1) {
+            return i;
+        }
+    }
+}
 ```
 
 ### **...**

solution/2900-2999/2923.Find Champion I/Solution.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    int findChampion(vector<vector<int>>& grid) {
+        int n = grid.size();
+        for (int i = 0;; ++i) {
+            int cnt = 0;
+            for (int j = 0; j < n; ++j) {
+                if (i != j && grid[i][j] == 1) {
+                    ++cnt;
+                }
+            }
+            if (cnt == n - 1) {
+                return i;
+            }
+        }
+    }
+};

solution/2900-2999/2923.Find Champion I/Solution.go

@@ -0,0 +1,14 @@
+func findChampion(grid [][]int) int {
+	n := len(grid)
+	for i := 0; ; i++ {
+		cnt := 0
+		for j, x := range grid[i] {
+			if i != j && x == 1 {
+				cnt++
+			}
+		}
+		if cnt == n-1 {
+			return i
+		}
+	}
+}

solution/2900-2999/2923.Find Champion I/Solution.java

@@ -0,0 +1,16 @@
+class Solution {
+    public int findChampion(int[][] grid) {
+        int n = grid.length;
+        for (int i = 0;; ++i) {
+            int cnt = 0;
+            for (int j = 0; j < n; ++j) {
+                if (i != j && grid[i][j] == 1) {
+                    ++cnt;
+                }
+            }
+            if (cnt == n - 1) {
+                return i;
+            }
+        }
+    }
+}

solution/2900-2999/2923.Find Champion I/Solution.py

@@ -0,0 +1,5 @@
+class Solution:
+    def findChampion(self, grid: List[List[int]]) -> int:
+        for i, row in enumerate(grid):
+            if all(x == 1 for j, x in enumerate(row) if i != j):
+                return i

solution/2900-2999/2923.Find Champion I/Solution.ts

@@ -0,0 +1,13 @@
+function findChampion(grid: number[][]): number {
+    for (let i = 0, n = grid.length; ; ++i) {
+        let cnt = 0;
+        for (let j = 0; j < n; ++j) {
+            if (i !== j && grid[i][j] === 1) {
+                ++cnt;
+            }
+        }
+        if (cnt === n - 1) {
+            return i;
+        }
+    }
+}