diff --git a/solution/0300-0399/0368.Largest Divisible Subset/README.md b/solution/0300-0399/0368.Largest Divisible Subset/README.md
index b3d3b284eedf3..881d96ad06ea6 100644
--- a/solution/0300-0399/0368.Largest Divisible Subset/README.md	
+++ b/solution/0300-0399/0368.Largest Divisible Subset/README.md	
@@ -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 -->
diff --git a/solution/0300-0399/0368.Largest Divisible Subset/README_EN.md b/solution/0300-0399/0368.Largest Divisible Subset/README_EN.md
index dc4c6e2a9992c..9fb8ce2e6d1a1 100644
--- a/solution/0300-0399/0368.Largest Divisible Subset/README_EN.md	
+++ b/solution/0300-0399/0368.Largest Divisible Subset/README_EN.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 -->
diff --git a/solution/0300-0399/0368.Largest Divisible Subset/Solution.cpp b/solution/0300-0399/0368.Largest Divisible Subset/Solution.cpp
index 769a58dba948a..b6834c46b9c0a 100644
--- a/solution/0300-0399/0368.Largest Divisible Subset/Solution.cpp	
+++ b/solution/0300-0399/0368.Largest Divisible Subset/Solution.cpp	
@@ -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;
diff --git a/solution/0300-0399/0368.Largest Divisible Subset/Solution.rs b/solution/0300-0399/0368.Largest Divisible Subset/Solution.rs
new file mode 100644
index 0000000000000..cb9cbc00f9d5d
--- /dev/null
+++ b/solution/0300-0399/0368.Largest Divisible Subset/Solution.rs	
@@ -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
+    }
+}
\ No newline at end of file
diff --git a/solution/0300-0399/0368.Largest Divisible Subset/Solution.ts b/solution/0300-0399/0368.Largest Divisible Subset/Solution.ts
new file mode 100644
index 0000000000000..1f73b5644ea8b
--- /dev/null
+++ b/solution/0300-0399/0368.Largest Divisible Subset/Solution.ts	
@@ -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;
+}
\ No newline at end of file