feat: add solutions to lc problem: No.2614 (#4490)

No.2614.Prime In Diagonal

Author: yanglbme

solution/2600-2699/2614.Prime In Diagonal/README.md

@@ -194,6 +194,36 @@ func isPrime(x int) bool {
 }
 ```
 
+#### TypeScript
+
+```ts
+function diagonalPrime(nums: number[][]): number {
+    const n = nums.length;
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        if (isPrime(nums[i][i])) {
+            ans = Math.max(ans, nums[i][i]);
+        }
+        if (isPrime(nums[i][n - i - 1])) {
+            ans = Math.max(ans, nums[i][n - i - 1]);
+        }
+    }
+    return ans;
+}
+
+function isPrime(x: number): boolean {
+    if (x < 2) {
+        return false;
+    }
+    for (let i = 2; i <= Math.floor(x / i); ++i) {
+        if (x % i === 0) {
+            return false;
+        }
+    }
+    return true;
+}
+```
+
 #### Rust
 
 ```rust
@@ -231,6 +261,40 @@ impl Solution {
 }
 ```
 
+#### JavaScript
+
+```js
+/**
+ * @param {number[][]} nums
+ * @return {number}
+ */
+var diagonalPrime = function (nums) {
+    let ans = 0;
+    const n = nums.length;
+    for (let i = 0; i < n; i++) {
+        if (isPrime(nums[i][i])) {
+            ans = Math.max(ans, nums[i][i]);
+        }
+        if (isPrime(nums[i][n - i - 1])) {
+            ans = Math.max(ans, nums[i][n - i - 1]);
+        }
+    }
+    return ans;
+};
+
+function isPrime(x) {
+    if (x < 2) {
+        return false;
+    }
+    for (let i = 2; i * i <= x; i++) {
+        if (x % i === 0) {
+            return false;
+        }
+    }
+    return true;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2600-2699/2614.Prime In Diagonal/README_EN.md

@@ -192,6 +192,36 @@ func isPrime(x int) bool {
 }
 ```
 
+#### TypeScript
+
+```ts
+function diagonalPrime(nums: number[][]): number {
+    const n = nums.length;
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        if (isPrime(nums[i][i])) {
+            ans = Math.max(ans, nums[i][i]);
+        }
+        if (isPrime(nums[i][n - i - 1])) {
+            ans = Math.max(ans, nums[i][n - i - 1]);
+        }
+    }
+    return ans;
+}
+
+function isPrime(x: number): boolean {
+    if (x < 2) {
+        return false;
+    }
+    for (let i = 2; i <= Math.floor(x / i); ++i) {
+        if (x % i === 0) {
+            return false;
+        }
+    }
+    return true;
+}
+```
+
 #### Rust
 
 ```rust
@@ -229,6 +259,40 @@ impl Solution {
 }
 ```
 
+#### JavaScript
+
+```js
+/**
+ * @param {number[][]} nums
+ * @return {number}
+ */
+var diagonalPrime = function (nums) {
+    let ans = 0;
+    const n = nums.length;
+    for (let i = 0; i < n; i++) {
+        if (isPrime(nums[i][i])) {
+            ans = Math.max(ans, nums[i][i]);
+        }
+        if (isPrime(nums[i][n - i - 1])) {
+            ans = Math.max(ans, nums[i][n - i - 1]);
+        }
+    }
+    return ans;
+};
+
+function isPrime(x) {
+    if (x < 2) {
+        return false;
+    }
+    for (let i = 2; i * i <= x; i++) {
+        if (x % i === 0) {
+            return false;
+        }
+    }
+    return true;
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2600-2699/2614.Prime In Diagonal/Solution.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} nums
+ * @return {number}
+ */
+var diagonalPrime = function (nums) {
+    let ans = 0;
+    const n = nums.length;
+    for (let i = 0; i < n; i++) {
+        if (isPrime(nums[i][i])) {
+            ans = Math.max(ans, nums[i][i]);
+        }
+        if (isPrime(nums[i][n - i - 1])) {
+            ans = Math.max(ans, nums[i][n - i - 1]);
+        }
+    }
+    return ans;
+};
+
+function isPrime(x) {
+    if (x < 2) {
+        return false;
+    }
+    for (let i = 2; i * i <= x; i++) {
+        if (x % i === 0) {
+            return false;
+        }
+    }
+    return true;
+}

solution/2600-2699/2614.Prime In Diagonal/Solution.ts

@@ -0,0 +1,25 @@
+function diagonalPrime(nums: number[][]): number {
+    const n = nums.length;
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        if (isPrime(nums[i][i])) {
+            ans = Math.max(ans, nums[i][i]);
+        }
+        if (isPrime(nums[i][n - i - 1])) {
+            ans = Math.max(ans, nums[i][n - i - 1]);
+        }
+    }
+    return ans;
+}
+
+function isPrime(x: number): boolean {
+    if (x < 2) {
+        return false;
+    }
+    for (let i = 2; i <= Math.floor(x / i); ++i) {
+        if (x % i === 0) {
+            return false;
+        }
+    }
+    return true;
+}