Merge branch 'doocs:main' into main

Author: Nothing-avil

images/starcharts.svg

@@ -114,6 +114,31 @@ WHERE
     );
 ```
 
+### Pandas
+
+```python
+import pandas as pd
+
+
+def department_highest_salary(
+    employee: pd.DataFrame, department: pd.DataFrame
+) -> pd.DataFrame:
+    # Merge the two tables on departmentId and department id
+    merged = employee.merge(department, left_on='departmentId', right_on='id')
+
+    # Find the maximum salary for each department
+    max_salaries = merged.groupby('departmentId')['salary'].transform('max')
+
+    # Filter employees who have the highest salary in their department
+    top_earners = merged[merged['salary'] == max_salaries]
+
+    # Select required columns and rename them
+    result = top_earners[['name_y', 'name_x', 'salary']].copy()
+    result.columns = ['Department', 'Employee', 'Salary']
+
+    return result
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0100-0199/0184.Department Highest Salary/README.md

@@ -116,6 +116,31 @@ WHERE
     );
 ```
 
+### Pandas
+
+```python
+import pandas as pd
+
+
+def department_highest_salary(
+    employee: pd.DataFrame, department: pd.DataFrame
+) -> pd.DataFrame:
+    # Merge the two tables on departmentId and department id
+    merged = employee.merge(department, left_on='departmentId', right_on='id')
+
+    # Find the maximum salary for each department
+    max_salaries = merged.groupby('departmentId')['salary'].transform('max')
+
+    # Filter employees who have the highest salary in their department
+    top_earners = merged[merged['salary'] == max_salaries]
+
+    # Select required columns and rename them
+    result = top_earners[['name_y', 'name_x', 'salary']].copy()
+    result.columns = ['Department', 'Employee', 'Salary']
+
+    return result
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0100-0199/0184.Department Highest Salary/README_EN.md

@@ -0,0 +1,20 @@
+import pandas as pd
+
+
+def department_highest_salary(
+    employee: pd.DataFrame, department: pd.DataFrame
+) -> pd.DataFrame:
+    # Merge the two tables on departmentId and department id
+    merged = employee.merge(department, left_on='departmentId', right_on='id')
+
+    # Find the maximum salary for each department
+    max_salaries = merged.groupby('departmentId')['salary'].transform('max')
+
+    # Filter employees who have the highest salary in their department
+    top_earners = merged[merged['salary'] == max_salaries]
+
+    # Select required columns and rename them
+    result = top_earners[['name_y', 'name_x', 'salary']].copy()
+    result.columns = ['Department', 'Employee', 'Salary']
+
+    return result

solution/0100-0199/0184.Department Highest Salary/Solution.py

@@ -141,7 +141,7 @@ class Solution {
 class Solution {
 public:
     vector<int> largestDivisibleSubset(vector<int>& nums) {
-        sort(nums.begin(), nums.end());
+        ranges::sort(nums);
         int n = nums.size();
         int f[n];
         int k = 0;
@@ -201,6 +201,79 @@ func largestDivisibleSubset(nums []int) (ans []int) {
 }
 ```
 
+#### TypeScript
+
+```ts
+function largestDivisibleSubset(nums: number[]): number[] {
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+    const f: number[] = Array(n).fill(1);
+    let k = 0;
+
+    for (let i = 0; i < n; ++i) {
+        for (let j = 0; j < i; ++j) {
+            if (nums[i] % nums[j] === 0) {
+                f[i] = Math.max(f[i], f[j] + 1);
+            }
+        }
+        if (f[k] < f[i]) {
+            k = i;
+        }
+    }
+
+    let m = f[k];
+    const ans: number[] = [];
+    for (let i = k; m > 0; --i) {
+        if (nums[k] % nums[i] === 0 && f[i] === m) {
+            ans.push(nums[i]);
+            k = i;
+            --m;
+        }
+    }
+
+    return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+    pub fn largest_divisible_subset(nums: Vec<i32>) -> Vec<i32> {
+        let mut nums = nums;
+        nums.sort();
+
+        let n = nums.len();
+        let mut f = vec![1; n];
+        let mut k = 0;
+
+        for i in 0..n {
+            for j in 0..i {
+                if nums[i] % nums[j] == 0 {
+                    f[i] = f[i].max(f[j] + 1);
+                }
+            }
+            if f[k] < f[i] {
+                k = i;
+            }
+        }
+
+        let mut m = f[k];
+        let mut ans = Vec::new();
+
+        for i in (0..=k).rev() {
+            if nums[k] % nums[i] == 0 && f[i] == m {
+                ans.push(nums[i]);
+                k = i;
+                m -= 1;
+            }
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0300-0399/0368.Largest Divisible Subset/README.md

@@ -129,7 +129,7 @@ class Solution {
 class Solution {
 public:
     vector<int> largestDivisibleSubset(vector<int>& nums) {
-        sort(nums.begin(), nums.end());
+        ranges::sort(nums);
         int n = nums.size();
         int f[n];
         int k = 0;
@@ -189,6 +189,79 @@ func largestDivisibleSubset(nums []int) (ans []int) {
 }
 ```
 
+#### TypeScript
+
+```ts
+function largestDivisibleSubset(nums: number[]): number[] {
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+    const f: number[] = Array(n).fill(1);
+    let k = 0;
+
+    for (let i = 0; i < n; ++i) {
+        for (let j = 0; j < i; ++j) {
+            if (nums[i] % nums[j] === 0) {
+                f[i] = Math.max(f[i], f[j] + 1);
+            }
+        }
+        if (f[k] < f[i]) {
+            k = i;
+        }
+    }
+
+    let m = f[k];
+    const ans: number[] = [];
+    for (let i = k; m > 0; --i) {
+        if (nums[k] % nums[i] === 0 && f[i] === m) {
+            ans.push(nums[i]);
+            k = i;
+            --m;
+        }
+    }
+
+    return ans;
+}
+```
+
+#### Rust
+
+```rust
+impl Solution {
+    pub fn largest_divisible_subset(nums: Vec<i32>) -> Vec<i32> {
+        let mut nums = nums;
+        nums.sort();
+
+        let n = nums.len();
+        let mut f = vec![1; n];
+        let mut k = 0;
+
+        for i in 0..n {
+            for j in 0..i {
+                if nums[i] % nums[j] == 0 {
+                    f[i] = f[i].max(f[j] + 1);
+                }
+            }
+            if f[k] < f[i] {
+                k = i;
+            }
+        }
+
+        let mut m = f[k];
+        let mut ans = Vec::new();
+
+        for i in (0..=k).rev() {
+            if nums[k] % nums[i] == 0 && f[i] == m {
+                ans.push(nums[i]);
+                k = i;
+                m -= 1;
+            }
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/0300-0399/0368.Largest Divisible Subset/README_EN.md

@@ -1,7 +1,7 @@
 class Solution {
 public:
     vector<int> largestDivisibleSubset(vector<int>& nums) {
-        sort(nums.begin(), nums.end());
+        ranges::sort(nums);
         int n = nums.size();
         int f[n];
         int k = 0;

solution/0300-0399/0368.Largest Divisible Subset/Solution.cpp

@@ -0,0 +1,34 @@
+impl Solution {
+    pub fn largest_divisible_subset(nums: Vec<i32>) -> Vec<i32> {
+        let mut nums = nums;
+        nums.sort();
+
+        let n = nums.len();
+        let mut f = vec![1; n];
+        let mut k = 0;
+
+        for i in 0..n {
+            for j in 0..i {
+                if nums[i] % nums[j] == 0 {
+                    f[i] = f[i].max(f[j] + 1);
+                }
+            }
+            if f[k] < f[i] {
+                k = i;
+            }
+        }
+
+        let mut m = f[k];
+        let mut ans = Vec::new();
+
+        for i in (0..=k).rev() {
+            if nums[k] % nums[i] == 0 && f[i] == m {
+                ans.push(nums[i]);
+                k = i;
+                m -= 1;
+            }
+        }
+
+        ans
+    }
+}

solution/0300-0399/0368.Largest Divisible Subset/Solution.rs

@@ -0,0 +1,29 @@
+function largestDivisibleSubset(nums: number[]): number[] {
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+    const f: number[] = Array(n).fill(1);
+    let k = 0;
+
+    for (let i = 0; i < n; ++i) {
+        for (let j = 0; j < i; ++j) {
+            if (nums[i] % nums[j] === 0) {
+                f[i] = Math.max(f[i], f[j] + 1);
+            }
+        }
+        if (f[k] < f[i]) {
+            k = i;
+        }
+    }
+
+    let m = f[k];
+    const ans: number[] = [];
+    for (let i = k; m > 0; --i) {
+        if (nums[k] % nums[i] === 0 && f[i] === m) {
+            ans.push(nums[i]);
+            k = i;
+            --m;
+        }
+    }
+
+    return ans;
+}