diff --git a/solution/3500-3599/3531.Count Covered Buildings/README.md b/solution/3500-3599/3531.Count Covered Buildings/README.md
index a8c932f5fbab2..08e8ab02924f0 100644
--- a/solution/3500-3599/3531.Count Covered Buildings/README.md	
+++ b/solution/3500-3599/3531.Count Covered Buildings/README.md	
@@ -297,6 +297,96 @@ function countCoveredBuildings(n: number, buildings: number[][]): number {
 }
 ```
 
+#### Rust
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn count_covered_buildings(_n: i32, buildings: Vec<Vec<i32>>) -> i32 {
+        let mut g1: HashMap<i32, Vec<i32>> = HashMap::new();
+        let mut g2: HashMap<i32, Vec<i32>> = HashMap::new();
+
+        for b in &buildings {
+            let x = b[0];
+            let y = b[1];
+            g1.entry(x).or_insert(Vec::new()).push(y);
+            g2.entry(y).or_insert(Vec::new()).push(x);
+        }
+
+        for v in g1.values_mut() {
+            v.sort();
+        }
+        for v in g2.values_mut() {
+            v.sort();
+        }
+
+        let mut ans: i32 = 0;
+
+        for b in &buildings {
+            let x = b[0];
+            let y = b[1];
+
+            let l1 = g1.get(&x).unwrap();
+            let l2 = g2.get(&y).unwrap();
+
+            if l2[0] < x && x < l2[l2.len() - 1] && l1[0] < y && y < l1[l1.len() - 1] {
+                ans += 1;
+            }
+        }
+
+        ans
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int CountCoveredBuildings(int n, int[][] buildings) {
+        var g1 = new Dictionary<int, List<int>>();
+        var g2 = new Dictionary<int, List<int>>();
+
+        foreach (var b in buildings) {
+            int x = b[0], y = b[1];
+
+            if (!g1.ContainsKey(x)) {
+                g1[x] = new List<int>();
+            }
+            g1[x].Add(y);
+
+            if (!g2.ContainsKey(y)) {
+                g2[y] = new List<int>();
+            }
+            g2[y].Add(x);
+        }
+
+        foreach (var kv in g1) {
+            kv.Value.Sort();
+        }
+        foreach (var kv in g2) {
+            kv.Value.Sort();
+        }
+
+        int ans = 0;
+
+        foreach (var b in buildings) {
+            int x = b[0], y = b[1];
+            var l1 = g1[x];
+            var l2 = g2[y];
+
+            if (l2[0] < x && x < l2[l2.Count - 1] &&
+                l1[0] < y && y < l1[l1.Count - 1]) {
+                ans++;
+            }
+        }
+
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/3500-3599/3531.Count Covered Buildings/README_EN.md b/solution/3500-3599/3531.Count Covered Buildings/README_EN.md
index 22fafc112f6af..f4e0c94b08abd 100644
--- a/solution/3500-3599/3531.Count Covered Buildings/README_EN.md	
+++ b/solution/3500-3599/3531.Count Covered Buildings/README_EN.md	
@@ -295,6 +295,96 @@ function countCoveredBuildings(n: number, buildings: number[][]): number {
 }
 ```
 
+#### Rust
+
+```rust
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn count_covered_buildings(_n: i32, buildings: Vec<Vec<i32>>) -> i32 {
+        let mut g1: HashMap<i32, Vec<i32>> = HashMap::new();
+        let mut g2: HashMap<i32, Vec<i32>> = HashMap::new();
+
+        for b in &buildings {
+            let x = b[0];
+            let y = b[1];
+            g1.entry(x).or_insert(Vec::new()).push(y);
+            g2.entry(y).or_insert(Vec::new()).push(x);
+        }
+
+        for v in g1.values_mut() {
+            v.sort();
+        }
+        for v in g2.values_mut() {
+            v.sort();
+        }
+
+        let mut ans: i32 = 0;
+
+        for b in &buildings {
+            let x = b[0];
+            let y = b[1];
+
+            let l1 = g1.get(&x).unwrap();
+            let l2 = g2.get(&y).unwrap();
+
+            if l2[0] < x && x < l2[l2.len() - 1] && l1[0] < y && y < l1[l1.len() - 1] {
+                ans += 1;
+            }
+        }
+
+        ans
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int CountCoveredBuildings(int n, int[][] buildings) {
+        var g1 = new Dictionary<int, List<int>>();
+        var g2 = new Dictionary<int, List<int>>();
+
+        foreach (var b in buildings) {
+            int x = b[0], y = b[1];
+
+            if (!g1.ContainsKey(x)) {
+                g1[x] = new List<int>();
+            }
+            g1[x].Add(y);
+
+            if (!g2.ContainsKey(y)) {
+                g2[y] = new List<int>();
+            }
+            g2[y].Add(x);
+        }
+
+        foreach (var kv in g1) {
+            kv.Value.Sort();
+        }
+        foreach (var kv in g2) {
+            kv.Value.Sort();
+        }
+
+        int ans = 0;
+
+        foreach (var b in buildings) {
+            int x = b[0], y = b[1];
+            var l1 = g1[x];
+            var l2 = g2[y];
+
+            if (l2[0] < x && x < l2[l2.Count - 1] &&
+                l1[0] < y && y < l1[l1.Count - 1]) {
+                ans++;
+            }
+        }
+
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/3500-3599/3531.Count Covered Buildings/Solution.cs b/solution/3500-3599/3531.Count Covered Buildings/Solution.cs
new file mode 100644
index 0000000000000..c9ce73f13391e
--- /dev/null
+++ b/solution/3500-3599/3531.Count Covered Buildings/Solution.cs	
@@ -0,0 +1,42 @@
+public class Solution {
+    public int CountCoveredBuildings(int n, int[][] buildings) {
+        var g1 = new Dictionary<int, List<int>>();
+        var g2 = new Dictionary<int, List<int>>();
+
+        foreach (var b in buildings) {
+            int x = b[0], y = b[1];
+
+            if (!g1.ContainsKey(x)) {
+                g1[x] = new List<int>();
+            }
+            g1[x].Add(y);
+
+            if (!g2.ContainsKey(y)) {
+                g2[y] = new List<int>();
+            }
+            g2[y].Add(x);
+        }
+
+        foreach (var kv in g1) {
+            kv.Value.Sort();
+        }
+        foreach (var kv in g2) {
+            kv.Value.Sort();
+        }
+
+        int ans = 0;
+
+        foreach (var b in buildings) {
+            int x = b[0], y = b[1];
+            var l1 = g1[x];
+            var l2 = g2[y];
+
+            if (l2[0] < x && x < l2[l2.Count - 1] &&
+                l1[0] < y && y < l1[l1.Count - 1]) {
+                ans++;
+            }
+        }
+
+        return ans;
+    }
+}
diff --git a/solution/3500-3599/3531.Count Covered Buildings/Solution.rs b/solution/3500-3599/3531.Count Covered Buildings/Solution.rs
new file mode 100644
index 0000000000000..c144f193ffe33
--- /dev/null
+++ b/solution/3500-3599/3531.Count Covered Buildings/Solution.rs	
@@ -0,0 +1,38 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn count_covered_buildings(_n: i32, buildings: Vec<Vec<i32>>) -> i32 {
+        let mut g1: HashMap<i32, Vec<i32>> = HashMap::new();
+        let mut g2: HashMap<i32, Vec<i32>> = HashMap::new();
+
+        for b in &buildings {
+            let x = b[0];
+            let y = b[1];
+            g1.entry(x).or_insert(Vec::new()).push(y);
+            g2.entry(y).or_insert(Vec::new()).push(x);
+        }
+
+        for v in g1.values_mut() {
+            v.sort();
+        }
+        for v in g2.values_mut() {
+            v.sort();
+        }
+
+        let mut ans: i32 = 0;
+
+        for b in &buildings {
+            let x = b[0];
+            let y = b[1];
+
+            let l1 = g1.get(&x).unwrap();
+            let l2 = g2.get(&y).unwrap();
+
+            if l2[0] < x && x < l2[l2.len() - 1] && l1[0] < y && y < l1[l1.len() - 1] {
+                ans += 1;
+            }
+        }
+
+        ans
+    }
+}