diff --git a/README.md b/README.md
index f7a4d082..ecaa1376 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,33 @@
 # Competitive_Coding-3
 
 Please submit the interview problems posted in slack channel here. The problems and statements are intentionally not shown here so that students are not able to see them in advance 
+
+532. K-diff Pairs in an Array
+
+Given an array of integers nums and an integer k, return the number of unique k-diff pairs in the array.
+
+A k-diff pair is an integer pair (nums[i], nums[j]), where the following are true:
+
+0 <= i, j < nums.length
+i != j
+|nums[i] - nums[j]| == k
+Notice that |val| denotes the absolute value of val.
+
+ 
+
+Example 1:
+
+Input: nums = [3,1,4,1,5], k = 2
+Output: 2
+Explanation: There are two 2-diff pairs in the array, (1, 3) and (3, 5).
+Although we have two 1s in the input, we should only return the number of unique pairs.
+Example 2:
+
+Input: nums = [1,2,3,4,5], k = 1
+Output: 4
+Explanation: There are four 1-diff pairs in the array, (1, 2), (2, 3), (3, 4) and (4, 5).
+Example 3:
+
+Input: nums = [1,3,1,5,4], k = 0
+Output: 1
+Explanation: There is one 0-diff pair in the array, (1, 1).
\ No newline at end of file
diff --git a/Sample.java b/Sample.java
deleted file mode 100644
index f5c45b5f..00000000
--- a/Sample.java
+++ /dev/null
@@ -1,7 +0,0 @@
-// Time Complexity :
-// Space Complexity :
-// Did this code successfully run on Leetcode :
-// Any problem you faced while coding this :
-
-
-// Your code here along with comments explaining your approach
\ No newline at end of file
diff --git a/Sample.py b/Sample.py
new file mode 100644
index 00000000..64212775
--- /dev/null
+++ b/Sample.py
@@ -0,0 +1,41 @@
+# // Time Complexity : O(n)
+# // Space Complexity : O(n)
+# // Did this code successfully run on Leetcode : Yes
+# // Any problem you faced while coding this : Yes
+
+
+# // Your code here along with comments explaining your approach
+
+# Used a **frequency map (Counter)** to efficiently find unique k-diff pairs:
+
+# 1. **For k = 0**: Count how many numbers appear **at least twice** (since pairs must be `(x, x)`)
+# 2. **For k > 0**: For each unique number `x`, check if `x + k` exists in the map (avoids duplicates by only checking one direction)
+
+# **Key insight**: By only checking `x + k` (not `x - k`), you ensure each pair `(x, x+k)` is counted **exactly once**.
+
+# - **Time Complexity**: `O(N)` — single pass through unique elements  
+# - **Space Complexity**: `O(N)` — for the frequency map
+
+
+class Solution:
+    def findPairs(self, nums: List[int], k: int) -> int:
+        hashmap = Counter(nums)
+        count=0
+        res = []
+        for key, value in hashmap.items():
+            if k == 0:
+                if value > 1:
+                    if (key,key) not in res:
+                        res.append([key,key])
+                        count += 1
+            else:
+                if key + k in hashmap:
+                    if sorted([key+k,key]) not in res:
+                        res.append(sorted([key+k,key]))
+                        count += 1
+        print(res)       
+        return count
+        
+
+
+