From 9f69c4161945281cd3cf9a636fda40f7c7680548 Mon Sep 17 00:00:00 2001
From: Sowmyanidi <nidsowmya@gmail.com>
Date: Sat, 21 Sep 2024 19:50:26 +0530
Subject: [PATCH 1/5] 20 & 21 September

---
 Sowmya/3Sum.py                | 17 +++++++++++++++++
 Sowmya/BuySellStock1.java     | 18 ++++++++++++++++++
 Sowmya/ContainsMostWater.java | 26 ++++++++++++++++++++++++++
 Sowmya/DuplicateNum.java      | 22 ++++++++++++++++++++++
 Sowmya/FindDuplicates.java    | 16 ++++++++++++++++
 Sowmya/MoveZeros.java         | 14 ++++++++++++++
 Sowmya/RemoveDuplicates.java  | 18 ++++++++++++++++++
 Sowmya/SetZeros.py            | 19 +++++++++++++++++++
 Sowmya/SortColors.java        | 25 +++++++++++++++++++++++++
 Sowmya/SubDivisible.java      | 21 +++++++++++++++++++++
 Sowmya/TwoSum.java            | 14 ++++++++++++++
 11 files changed, 210 insertions(+)
 create mode 100644 Sowmya/3Sum.py
 create mode 100644 Sowmya/BuySellStock1.java
 create mode 100644 Sowmya/ContainsMostWater.java
 create mode 100644 Sowmya/DuplicateNum.java
 create mode 100644 Sowmya/FindDuplicates.java
 create mode 100644 Sowmya/MoveZeros.java
 create mode 100644 Sowmya/RemoveDuplicates.java
 create mode 100644 Sowmya/SetZeros.py
 create mode 100644 Sowmya/SortColors.java
 create mode 100644 Sowmya/SubDivisible.java
 create mode 100644 Sowmya/TwoSum.java

diff --git a/Sowmya/3Sum.py b/Sowmya/3Sum.py
new file mode 100644
index 0000000..96abd65
--- /dev/null
+++ b/Sowmya/3Sum.py
@@ -0,0 +1,17 @@
+class Solution:
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        if len(set(nums))==1 and nums[0]==0:
+            return [[0,0,0]]
+        hashmap = {}
+        result = set()
+
+        for i in range(len(nums)):
+            hashmap[nums[i]]=i
+
+        for i in range(len(nums)):
+            for j in range(i+1, len(nums)):
+                k = -(nums[i]+nums[j])
+                if k in hashmap.keys() and (hashmap[k]!=i and hashmap[k]!=j):
+                    result.add(tuple(sorted([nums[i], nums[j], k])))
+        
+        return result
\ No newline at end of file
diff --git a/Sowmya/BuySellStock1.java b/Sowmya/BuySellStock1.java
new file mode 100644
index 0000000..dca0240
--- /dev/null
+++ b/Sowmya/BuySellStock1.java
@@ -0,0 +1,18 @@
+class BuySellStock1 {
+    public int maxProfit(int[] prices) {
+        int min_price = Integer.MAX_VALUE;
+        int profit = 0;
+        for(int i = 0; i < prices.length; i++){
+            if(min_price > prices[i]){
+                min_price = prices[i];
+            }
+            else if(min_price < prices[i]){
+                int diff = prices[i] - min_price;
+                if(diff > profit){
+                    profit = diff;
+                }
+            }
+        }
+        return profit;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/ContainsMostWater.java b/Sowmya/ContainsMostWater.java
new file mode 100644
index 0000000..32c2830
--- /dev/null
+++ b/Sowmya/ContainsMostWater.java
@@ -0,0 +1,26 @@
+class ContainsMostWater {
+    public int maxArea(int[] height) {
+        int max_water = 0;
+        int i = 0;
+        int j = height.length - 1;
+
+        while(i<j){
+            if(height[i] < height[j]){
+                int product = height[i]*(j-i);
+                i += 1;
+                if(product > max_water){
+                    max_water = product;
+                }
+            }
+            else{
+                int product = height[j]*(j-i);
+                j -= 1;
+                if(product > max_water){
+                    max_water = product;
+                }
+            }
+        }
+
+        return max_water;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/DuplicateNum.java b/Sowmya/DuplicateNum.java
new file mode 100644
index 0000000..4ec4187
--- /dev/null
+++ b/Sowmya/DuplicateNum.java
@@ -0,0 +1,22 @@
+class DuplicateNum {
+    public int findDuplicate(int[] nums) {
+        int tortoise = 0;
+        int hare = 0;
+        for(int i = 0; i<nums.length; i++){
+            tortoise = nums[tortoise];
+            hare = nums[nums[hare]];
+            if(tortoise == hare){
+                break;
+            }
+        }
+        tortoise = 0;
+        for(int i = 0; i<nums.length; i++){
+            tortoise = nums[tortoise];
+            hare = nums[hare];
+            if(tortoise == hare){
+                break;
+            }
+        }
+        return tortoise;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/FindDuplicates.java b/Sowmya/FindDuplicates.java
new file mode 100644
index 0000000..4497d4a
--- /dev/null
+++ b/Sowmya/FindDuplicates.java
@@ -0,0 +1,16 @@
+import java.util.*;
+class FindDuplicates {
+    public List<Integer> findDuplicates(int[] nums) {
+        List<Integer> result = new ArrayList<Integer>();
+        for(int i = 0; i<nums.length; i++){
+            int ind = Math.abs(nums[i])-1;
+            if(nums[ind] < 0){
+                result.add(Math.abs(nums[i]));
+            }
+            else{
+                nums[ind] = 0 - nums[ind];
+            }
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/MoveZeros.java b/Sowmya/MoveZeros.java
new file mode 100644
index 0000000..e6936c2
--- /dev/null
+++ b/Sowmya/MoveZeros.java
@@ -0,0 +1,14 @@
+class MoveZeros {
+    public void moveZeroes(int[] nums) {
+        int k = 0;
+        for(int i = 0; i<nums.length; i++){
+            if(nums[i]!=0){
+                nums[k++] = nums[i];
+            }
+        }
+
+        for(int i = k; i<nums.length; i++){
+            nums[i] = 0;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/RemoveDuplicates.java b/Sowmya/RemoveDuplicates.java
new file mode 100644
index 0000000..1615bfe
--- /dev/null
+++ b/Sowmya/RemoveDuplicates.java
@@ -0,0 +1,18 @@
+class RemoveDuplicates {
+    public int removeDuplicates(int[] nums) {
+        int i = 0;
+        for(int num : nums){
+            if(i==0){
+                i+=1;
+            }
+            else if(nums[i-1]!=num){
+                nums[i]= num;
+                i+=1;
+            }
+        }
+        for(int j = 0; j<nums.length; j++){
+            System.out.print(nums[j] + " ");
+        }
+        return i;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/SetZeros.py b/Sowmya/SetZeros.py
new file mode 100644
index 0000000..1824191
--- /dev/null
+++ b/Sowmya/SetZeros.py
@@ -0,0 +1,19 @@
+class Solution:
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        """
+        Do not return anything, modify matrix in-place instead.
+        """
+        for i in range(len(matrix)):
+            for j in range(len(matrix[i])):
+                if matrix[i][j]==0:
+                    for k in range(len(matrix[i])):
+                        if matrix[i][k]!=0:
+                            matrix[i][k]='a'
+                    for k in range(len(matrix)):
+                        if matrix[k][j]!=0:
+                            matrix[k][j]='a'
+        
+        for i in range(len(matrix)):
+            for j in range(len(matrix[i])):
+                if matrix[i][j]=='a':
+                    matrix[i][j]=0
\ No newline at end of file
diff --git a/Sowmya/SortColors.java b/Sowmya/SortColors.java
new file mode 100644
index 0000000..a05578f
--- /dev/null
+++ b/Sowmya/SortColors.java
@@ -0,0 +1,25 @@
+class SortColors {
+    public void sortColors(int[] nums) {
+        int low = 0;
+        int high = nums.length - 1;
+        int mid = 0;
+        for(int i = 0; i<nums.length; i++){
+            if(nums[mid]==0){
+                int temp = nums[low];
+                nums[low] = nums[mid];
+                nums[mid] = temp;
+                low += 1;
+                mid += 1;
+            }
+            else if(nums[mid]==1){
+                mid += 1;
+            }
+            else if(nums[mid]==2){
+                int temp = nums[mid];
+                nums[mid] = nums[high];
+                nums[high] = temp;
+                high -= 1;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/SubDivisible.java b/Sowmya/SubDivisible.java
new file mode 100644
index 0000000..416a3e6
--- /dev/null
+++ b/Sowmya/SubDivisible.java
@@ -0,0 +1,21 @@
+import java.util.*;
+class SubDivisible {
+    public int subarraysDivByK(int[] nums, int k) {
+        HashMap <Integer, Integer> map = new HashMap<Integer, Integer>();
+        int result = 0;
+        map.put(0,1);
+        int sum = 0;
+        for(int i = 0; i<nums.length; i++){
+            sum += nums[i];
+            int remainder = sum%k;
+            if(remainder < 0){
+                remainder += k;
+            }
+            if(map.containsKey(remainder)){
+                result += map.get(remainder);
+            }
+            map.put(remainder, map.getOrDefault(remainder, 0)+1);
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/TwoSum.java b/Sowmya/TwoSum.java
new file mode 100644
index 0000000..f64bba9
--- /dev/null
+++ b/Sowmya/TwoSum.java
@@ -0,0 +1,14 @@
+import java.util.*;
+class TwoSum {
+    public int[] twoSum(int[] nums, int target) {
+        HashMap <Integer, Integer> hm = new HashMap<Integer, Integer>();
+        for(int i = 0; i<nums.length; i++){
+            int difference = target - nums[i];
+            if(hm.containsKey(difference)){
+                return new int[] {i, hm.get(difference)};
+            }
+            hm.put(nums[i], i);
+        }
+        return new int[] {};
+    }
+}
\ No newline at end of file

From b4b65549ffd8d48daa8dc86f8f36f2bc414bd560 Mon Sep 17 00:00:00 2001
From: Sowmyanidi <nidsowmya@gmail.com>
Date: Sun, 22 Sep 2024 11:59:02 +0530
Subject: [PATCH 2/5] Moved Files

---
 Sowmya/{ => Arrays}/3Sum.py                |  0
 Sowmya/{ => Arrays}/BuySellStock1.java     |  0
 Sowmya/{ => Arrays}/ContainsMostWater.java |  0
 Sowmya/{ => Arrays}/DuplicateNum.java      |  0
 Sowmya/{ => Arrays}/FindDuplicates.java    |  0
 Sowmya/Arrays/MajorityElement.java         | 18 ++++++++++++
 Sowmya/Arrays/MaxPoints.java               | 24 ++++++++++++++++
 Sowmya/Arrays/MergeSorted.java             | 33 ++++++++++++++++++++++
 Sowmya/{ => Arrays}/MoveZeros.java         |  0
 Sowmya/{ => Arrays}/RemoveDuplicates.java  |  0
 Sowmya/Arrays/ReverseWords.java            | 12 ++++++++
 Sowmya/{ => Arrays}/SetZeros.py            |  0
 Sowmya/{ => Arrays}/SortColors.java        |  0
 Sowmya/{ => Arrays}/SubDivisible.java      |  0
 Sowmya/Arrays/SubSumEqualsK.java           | 17 +++++++++++
 Sowmya/{ => Arrays}/TwoSum.java            |  0
 16 files changed, 104 insertions(+)
 rename Sowmya/{ => Arrays}/3Sum.py (100%)
 rename Sowmya/{ => Arrays}/BuySellStock1.java (100%)
 rename Sowmya/{ => Arrays}/ContainsMostWater.java (100%)
 rename Sowmya/{ => Arrays}/DuplicateNum.java (100%)
 rename Sowmya/{ => Arrays}/FindDuplicates.java (100%)
 create mode 100644 Sowmya/Arrays/MajorityElement.java
 create mode 100644 Sowmya/Arrays/MaxPoints.java
 create mode 100644 Sowmya/Arrays/MergeSorted.java
 rename Sowmya/{ => Arrays}/MoveZeros.java (100%)
 rename Sowmya/{ => Arrays}/RemoveDuplicates.java (100%)
 create mode 100644 Sowmya/Arrays/ReverseWords.java
 rename Sowmya/{ => Arrays}/SetZeros.py (100%)
 rename Sowmya/{ => Arrays}/SortColors.java (100%)
 rename Sowmya/{ => Arrays}/SubDivisible.java (100%)
 create mode 100644 Sowmya/Arrays/SubSumEqualsK.java
 rename Sowmya/{ => Arrays}/TwoSum.java (100%)

diff --git a/Sowmya/3Sum.py b/Sowmya/Arrays/3Sum.py
similarity index 100%
rename from Sowmya/3Sum.py
rename to Sowmya/Arrays/3Sum.py
diff --git a/Sowmya/BuySellStock1.java b/Sowmya/Arrays/BuySellStock1.java
similarity index 100%
rename from Sowmya/BuySellStock1.java
rename to Sowmya/Arrays/BuySellStock1.java
diff --git a/Sowmya/ContainsMostWater.java b/Sowmya/Arrays/ContainsMostWater.java
similarity index 100%
rename from Sowmya/ContainsMostWater.java
rename to Sowmya/Arrays/ContainsMostWater.java
diff --git a/Sowmya/DuplicateNum.java b/Sowmya/Arrays/DuplicateNum.java
similarity index 100%
rename from Sowmya/DuplicateNum.java
rename to Sowmya/Arrays/DuplicateNum.java
diff --git a/Sowmya/FindDuplicates.java b/Sowmya/Arrays/FindDuplicates.java
similarity index 100%
rename from Sowmya/FindDuplicates.java
rename to Sowmya/Arrays/FindDuplicates.java
diff --git a/Sowmya/Arrays/MajorityElement.java b/Sowmya/Arrays/MajorityElement.java
new file mode 100644
index 0000000..ef37262
--- /dev/null
+++ b/Sowmya/Arrays/MajorityElement.java
@@ -0,0 +1,18 @@
+class MajorityElement {
+    public int majorityElement(int[] nums) {
+        int selected_num = 0;
+        int count = 0;
+        for(int i = 0; i<nums.length; i++){
+            if(count == 0){
+                selected_num = nums[i];
+            }
+            if(nums[i]==selected_num){
+                count += 1;
+            }
+            else{
+                count -= 1;
+            }
+        }
+        return selected_num;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Arrays/MaxPoints.java b/Sowmya/Arrays/MaxPoints.java
new file mode 100644
index 0000000..8977790
--- /dev/null
+++ b/Sowmya/Arrays/MaxPoints.java
@@ -0,0 +1,24 @@
+class MaxPoints {
+    public int maxScore(int[] cardPoints, int k) {
+        int len = cardPoints.length;
+        int size = len - k;
+        int window = 0;
+        int points = 0;
+        for(int i = 0; i<len; i++){
+            points += cardPoints[i];
+        }
+        for(int i = 0; i<size; i++){
+            window += cardPoints[i];
+        }
+        int result = points - window;
+        int j = 0;
+        for(int i = size; i<len; i++){
+            window -= cardPoints[j++];
+            window += cardPoints[i];
+            if((points - window) > result){
+                result = points - window;
+            }
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Arrays/MergeSorted.java b/Sowmya/Arrays/MergeSorted.java
new file mode 100644
index 0000000..d237803
--- /dev/null
+++ b/Sowmya/Arrays/MergeSorted.java
@@ -0,0 +1,33 @@
+class MergeSorted {
+    public void merge(int[] nums1, int m, int[] nums2, int n) {
+        int p1 = m - 1;
+        int p2 = n - 1;
+        int p = m + n - 1;
+        while((p1>=0)&&(p2>=0)&&(p>=0)){
+            if(nums1[p1]>nums2[p2]){
+                nums1[p] = nums1[p1];
+                p1 -= 1;
+            }
+            else{
+                nums1[p] = nums2[p2];
+                p2 -= 1;
+            }
+            p -= 1;
+        }
+
+        if(p1 >= 0){
+            while(p>=0){
+                nums1[p] = nums1[p1];
+                p -= 1;
+                p1 -= 1;
+            }
+        }
+        if(p2 >= 0){
+            while(p>=0){
+                nums1[p] = nums2[p2];
+                p -= 1;
+                p2 -= 1;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/MoveZeros.java b/Sowmya/Arrays/MoveZeros.java
similarity index 100%
rename from Sowmya/MoveZeros.java
rename to Sowmya/Arrays/MoveZeros.java
diff --git a/Sowmya/RemoveDuplicates.java b/Sowmya/Arrays/RemoveDuplicates.java
similarity index 100%
rename from Sowmya/RemoveDuplicates.java
rename to Sowmya/Arrays/RemoveDuplicates.java
diff --git a/Sowmya/Arrays/ReverseWords.java b/Sowmya/Arrays/ReverseWords.java
new file mode 100644
index 0000000..73e9f9f
--- /dev/null
+++ b/Sowmya/Arrays/ReverseWords.java
@@ -0,0 +1,12 @@
+class ReverseWords {
+    public String reverseWords(String s) {
+        s = s.trim();
+        String[] words = s.split("\\s+");
+        StringBuffer output = new StringBuffer();
+        for(int i = words.length - 1; i>0; i--){
+            output.append(words[i]).append(" ");
+        }
+        output.append(words[0]);
+        return output.toString();
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/SetZeros.py b/Sowmya/Arrays/SetZeros.py
similarity index 100%
rename from Sowmya/SetZeros.py
rename to Sowmya/Arrays/SetZeros.py
diff --git a/Sowmya/SortColors.java b/Sowmya/Arrays/SortColors.java
similarity index 100%
rename from Sowmya/SortColors.java
rename to Sowmya/Arrays/SortColors.java
diff --git a/Sowmya/SubDivisible.java b/Sowmya/Arrays/SubDivisible.java
similarity index 100%
rename from Sowmya/SubDivisible.java
rename to Sowmya/Arrays/SubDivisible.java
diff --git a/Sowmya/Arrays/SubSumEqualsK.java b/Sowmya/Arrays/SubSumEqualsK.java
new file mode 100644
index 0000000..f330c44
--- /dev/null
+++ b/Sowmya/Arrays/SubSumEqualsK.java
@@ -0,0 +1,17 @@
+import java.util.*;
+class SubSumEqualsK {
+    public int subarraySum(int[] nums, int k) {
+        HashMap <Integer, Integer> map = new HashMap<Integer, Integer>();
+        map.put(0, 1);
+        int sum = 0;
+        int result = 0;
+        for(int i = 0; i<nums.length; i++){
+            sum += nums[i];
+            if(map.containsKey(sum-k)){
+                result += map.get(sum - k);
+            }
+            map.put(sum, map.getOrDefault(sum, 0)+1);
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/TwoSum.java b/Sowmya/Arrays/TwoSum.java
similarity index 100%
rename from Sowmya/TwoSum.java
rename to Sowmya/Arrays/TwoSum.java

From ac48942ea99bced2f996d5392f5331b4e3a3a3c1 Mon Sep 17 00:00:00 2001
From: Sowmyanidi <nidsowmya@gmail.com>
Date: Tue, 24 Sep 2024 17:51:45 +0530
Subject: [PATCH 3/5] strings

---
 Sowmya/Strings/CommonPrefix.java             | 23 +++++++++++++
 Sowmya/Strings/FirstOccurrence.java          | 10 ++++++
 Sowmya/Strings/GenParenthesis.java           | 32 +++++++++++++++++
 Sowmya/Strings/IntToRoman.java               | 30 ++++++++++++++++
 Sowmya/{Arrays => Strings}/ReverseWords.java |  0
 Sowmya/Strings/ValidPalindrome2.java         | 36 ++++++++++++++++++++
 Sowmya/Strings/ValidParenthesis.java         | 33 ++++++++++++++++++
 7 files changed, 164 insertions(+)
 create mode 100644 Sowmya/Strings/CommonPrefix.java
 create mode 100644 Sowmya/Strings/FirstOccurrence.java
 create mode 100644 Sowmya/Strings/GenParenthesis.java
 create mode 100644 Sowmya/Strings/IntToRoman.java
 rename Sowmya/{Arrays => Strings}/ReverseWords.java (100%)
 create mode 100644 Sowmya/Strings/ValidPalindrome2.java
 create mode 100644 Sowmya/Strings/ValidParenthesis.java

diff --git a/Sowmya/Strings/CommonPrefix.java b/Sowmya/Strings/CommonPrefix.java
new file mode 100644
index 0000000..74a4718
--- /dev/null
+++ b/Sowmya/Strings/CommonPrefix.java
@@ -0,0 +1,23 @@
+import java.util.*;
+class CommonPrefix {
+    public String longestCommonPrefix(String[] strs) {
+        
+        Arrays.sort(strs);
+        if(strs.length == 1){
+            return strs[0];
+        }
+        if(strs[0].length()==0){
+            return "";
+        }
+        String output = "";
+        String last = strs[strs.length - 1];
+        for(int i = 0; i<strs[0].length(); i++){
+            if(last.startsWith(output+strs[0].charAt(i))){
+                output += strs[0].charAt(i);
+                continue;
+            }
+            break;
+        }
+        return output;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Strings/FirstOccurrence.java b/Sowmya/Strings/FirstOccurrence.java
new file mode 100644
index 0000000..2460fbf
--- /dev/null
+++ b/Sowmya/Strings/FirstOccurrence.java
@@ -0,0 +1,10 @@
+class FristOccurrence {
+    public int strStr(String haystack, String needle) {
+        if(haystack.contains(needle)){
+            return haystack.indexOf(needle);
+        }
+        else{
+            return -1;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Strings/GenParenthesis.java b/Sowmya/Strings/GenParenthesis.java
new file mode 100644
index 0000000..9a5ed9c
--- /dev/null
+++ b/Sowmya/Strings/GenParenthesis.java
@@ -0,0 +1,32 @@
+class GenParenthesis {
+    public List<String> generateParenthesis(int n) {
+        ArrayList <String> result = new ArrayList<String>();
+        ArrayList <Character> sub = new ArrayList<Character>();
+        backtrack(result, sub, n, 0, 0);
+        return result;
+    }
+    public static void backtrack(ArrayList<String> result, ArrayList <Character> sub, int n, int open, int close){
+        if(sub.size()==2*n){
+            result.add(join(sub));
+        }
+        else{
+            if(open<n){
+                sub.add('(');
+                backtrack(result, sub, n, open+1, close);
+                sub.remove(sub.size() - 1);
+            }
+            if(close<open){
+                sub.add(')');
+                backtrack(result, sub, n, open, close+1);
+                sub.remove(sub.size() - 1);
+            }
+        }
+    }
+    public static String join(ArrayList<Character> sub){
+        StringBuffer output = new StringBuffer();
+        for(int i = 0; i<sub.size(); i++){
+            output.append(sub.get(i));
+        }
+        return output.toString();
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Strings/IntToRoman.java b/Sowmya/Strings/IntToRoman.java
new file mode 100644
index 0000000..b7f16ab
--- /dev/null
+++ b/Sowmya/Strings/IntToRoman.java
@@ -0,0 +1,30 @@
+import java.util.*;
+class IntToRoman {
+    public String intToRoman(int num) {
+        HashMap<Integer, String> numMap = new HashMap<>();
+
+        numMap.put(1, "I");
+        numMap.put(4, "IV");
+        numMap.put(5, "V");
+        numMap.put(9, "IX");
+        numMap.put(10, "X");
+        numMap.put(40, "XL");
+        numMap.put(50, "L");
+        numMap.put(90, "XC");
+        numMap.put(100, "C");
+        numMap.put(400, "CD");
+        numMap.put(500, "D");
+        numMap.put(900, "CM");
+        numMap.put(1000, "M");
+
+        StringBuffer result = new StringBuffer();
+        int[] numList = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+        for(int n : numList){
+            while(n<=num){
+                result.append(numMap.get(n));
+                num -= n;
+            }
+        }
+        return result.toString();
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Arrays/ReverseWords.java b/Sowmya/Strings/ReverseWords.java
similarity index 100%
rename from Sowmya/Arrays/ReverseWords.java
rename to Sowmya/Strings/ReverseWords.java
diff --git a/Sowmya/Strings/ValidPalindrome2.java b/Sowmya/Strings/ValidPalindrome2.java
new file mode 100644
index 0000000..0f945dd
--- /dev/null
+++ b/Sowmya/Strings/ValidPalindrome2.java
@@ -0,0 +1,36 @@
+class ValidPalindrome2 {
+    public boolean validPalindrome(String s) {
+        int i = 0, j = s.length() - 1;
+        while(i<j){
+            char ch1 = s.charAt(i);
+            char ch2 = s.charAt(j);
+            if(ch1==ch2){
+                i += 1;
+                j -= 1;
+            }
+            else{
+                if(isPalindrome(s.substring(i, j))){
+                    j -= 1;
+                }
+                else if(isPalindrome(s.substring(i+1, j+1))){
+                    i += 1;
+                }
+                else{
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    public static boolean isPalindrome(String s){
+        StringBuffer rev = new StringBuffer();
+        for(int i = s.length() - 1; i>=0; i--){
+            rev.append(s.charAt(i));
+        }
+        if(s.equals(rev.toString())){
+            return true;
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Strings/ValidParenthesis.java b/Sowmya/Strings/ValidParenthesis.java
new file mode 100644
index 0000000..8c7eea9
--- /dev/null
+++ b/Sowmya/Strings/ValidParenthesis.java
@@ -0,0 +1,33 @@
+import java.util.*;
+class ValidParenthesis {
+    public boolean isValid(String s) {
+        if(s.length()==1){
+            return false;
+        }
+        else{
+            Stack <Character> stack = new Stack<Character>();
+            HashMap <Character, Character> hm = new HashMap<Character, Character>();
+            hm.put(')','(');
+            hm.put(']','[');
+            hm.put('}','{');
+            for(int i = 0; i<s.length(); i++){
+                char ch = s.charAt(i);
+                if((ch==hm.get(')')) || (ch==hm.get(']')) || (ch==hm.get('}'))){
+                    stack.push(ch);
+                }
+                else if((ch==')') || (ch==']') || (ch=='}')){
+                    if((stack.size()==0) || (stack.pop()!=hm.get(ch))){
+                        return false;
+                    }
+                    else{
+                        continue;
+                    }
+                }
+            }
+            if(stack.size()>0){
+                return false;
+            }
+            return true;
+        }
+    }
+}
\ No newline at end of file

From f83828252e218ba68c50d4f3e942a51c3c5adb2e Mon Sep 17 00:00:00 2001
From: Sowmyanidi <nidsowmya@gmail.com>
Date: Wed, 25 Sep 2024 14:24:54 +0530
Subject: [PATCH 4/5] 24th

---
 Sowmya/Strings/GroupAna.java | 18 ++++++++++++++
 Sowmya/Strings/IntToWords.py | 46 ++++++++++++++++++++++++++++++++++++
 2 files changed, 64 insertions(+)
 create mode 100644 Sowmya/Strings/GroupAna.java
 create mode 100644 Sowmya/Strings/IntToWords.py

diff --git a/Sowmya/Strings/GroupAna.java b/Sowmya/Strings/GroupAna.java
new file mode 100644
index 0000000..fe99f82
--- /dev/null
+++ b/Sowmya/Strings/GroupAna.java
@@ -0,0 +1,18 @@
+import java.util.*;
+class GroupAna {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        HashMap <String, List<String>> map = new HashMap<String, List<String>>();
+        for(String str: strs){
+            char[] chArray = str.toCharArray();
+            Arrays.sort(chArray);
+            String key = new String(chArray);
+            if(!map.containsKey(key)){
+                map.put(key, new ArrayList<String>());
+            }
+            map.get(key).add(str);
+        }
+
+        List<List<String>> result = new ArrayList<>(map.values());
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Strings/IntToWords.py b/Sowmya/Strings/IntToWords.py
new file mode 100644
index 0000000..4204cc8
--- /dev/null
+++ b/Sowmya/Strings/IntToWords.py
@@ -0,0 +1,46 @@
+class Solution:
+    def numberToWords(self, num: int) -> str:
+        d = {0: "Zero", 1: "One", 2: "Two", 3: "Three", 4: "Four", 5: "Five", 6: "Six",
+            7: "Seven", 8: "Eight", 9: "Nine", 10: "Ten", 11: "Eleven", 12: "Twelve",
+            13: "Thirteen", 14: "Fourteen", 15: "Fifteen", 16: "Sixteen",
+            17: "Seventeen", 18: "Eighteen", 19: "Nineteen", 20: "Twenty", 30: "Thirty",
+            40: "Forty", 50: "Fifty", 60: "Sixty", 70: "Seventy", 80: "Eighty",
+            90: "Ninety", 100: "Hundred", 1000: "Thousand", 1000000: "Million",
+            1000000000: "Billion"
+            }
+
+        def lessThanThousand(n: int) -> str:
+            if(n==0):
+                return ""
+            elif(n>0 and n<20):
+                return d[n]
+            elif n%100==0:
+                return d[n//100]+" " + d[100]
+            elif n<100:
+                return d[n // 10 * 10] + ("" if n % 10 == 0 else " " + d[n % 10])
+            elif(n>100 and n<1000):
+                return d[n // 100] + " Hundred"+ ("" if n % 100 == 0 else " " + lessThanThousand(n%100))
+        
+        if(num<1000):
+            if num==0:
+                return d[num]
+            return lessThanThousand(num)
+        elif(num==1000):
+            return d[num//1000] + " " + d[1000]
+        else:
+            result = ""
+            billion = num // 1000000000
+            million = (num % 1000000000) // 1000000
+            thousand = (num % 1000000) // 1000
+            remainder = num % 1000
+            
+            if billion > 0:
+                result += lessThanThousand(billion) + " Billion"
+            if million > 0:
+                result += (" " if result else "") + lessThanThousand(million) + " Million"
+            if thousand > 0:
+                result += (" " if result else "") + lessThanThousand(thousand) + " Thousand"
+            if remainder > 0:
+                result += (" " if result else "") + lessThanThousand(remainder)
+            
+            return result.strip()
\ No newline at end of file

From 6e0449af24622178f3358fe5960fcde9f4573eba Mon Sep 17 00:00:00 2001
From: Sowmyanidi <nidsowmya@gmail.com>
Date: Tue, 8 Oct 2024 12:38:48 +0530
Subject: [PATCH 5/5] Mathematics

---
 Sowmya/Arrays/ChocolateDistribution.java    | 20 +++++++++++++
 Sowmya/Mathematics/AddBinary.java           | 32 +++++++++++++++++++++
 Sowmya/Mathematics/ExcelSheet.java          | 17 +++++++++++
 Sowmya/Mathematics/Happy.java               | 20 +++++++++++++
 Sowmya/Mathematics/KthFactor.java           | 15 ++++++++++
 Sowmya/Mathematics/MaximumProduct.java      | 11 +++++++
 Sowmya/Mathematics/MinToMakeArrayEqual.java | 19 ++++++++++++
 Sowmya/Mathematics/Missing.java             | 15 ++++++++++
 Sowmya/Mathematics/Palindrome.java          | 15 ++++++++++
 Sowmya/Mathematics/Power2.java              | 11 +++++++
 Sowmya/Mathematics/ReverseInt.java          | 22 ++++++++++++++
 11 files changed, 197 insertions(+)
 create mode 100644 Sowmya/Arrays/ChocolateDistribution.java
 create mode 100644 Sowmya/Mathematics/AddBinary.java
 create mode 100644 Sowmya/Mathematics/ExcelSheet.java
 create mode 100644 Sowmya/Mathematics/Happy.java
 create mode 100644 Sowmya/Mathematics/KthFactor.java
 create mode 100644 Sowmya/Mathematics/MaximumProduct.java
 create mode 100644 Sowmya/Mathematics/MinToMakeArrayEqual.java
 create mode 100644 Sowmya/Mathematics/Missing.java
 create mode 100644 Sowmya/Mathematics/Palindrome.java
 create mode 100644 Sowmya/Mathematics/Power2.java
 create mode 100644 Sowmya/Mathematics/ReverseInt.java

diff --git a/Sowmya/Arrays/ChocolateDistribution.java b/Sowmya/Arrays/ChocolateDistribution.java
new file mode 100644
index 0000000..ef54d7a
--- /dev/null
+++ b/Sowmya/Arrays/ChocolateDistribution.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class ChocolateDistribution
+{
+    public long findMinDiff (ArrayList<Integer> a, int n, int m)
+    {
+        int min_diff = Integer.MAX_VALUE;
+        Collections.sort(a);
+        int i = 0;
+        int j = m - 1;
+        while(j < n){
+            int diff = a.get(j) - a.get(i);
+            if(diff < min_diff){
+                min_diff = diff;
+            }
+            i += 1;
+            j += 1;
+        }
+        return min_diff;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Mathematics/AddBinary.java b/Sowmya/Mathematics/AddBinary.java
new file mode 100644
index 0000000..54551d3
--- /dev/null
+++ b/Sowmya/Mathematics/AddBinary.java
@@ -0,0 +1,32 @@
+class AddBinary {
+    public String addBinary(String a, String b) {
+        String result = "";
+        int i = a.length() - 1;
+        int j = b.length() - 1;
+        int carry = 0;
+        while((i>=0)&&(j>=0)){
+            int n1 = a.charAt(i) - '0';
+            int n2 = b.charAt(j) - '0';
+            result = String.valueOf(n1^n2^carry) + result;
+            carry = (n1 & n2) | (carry & (n1 ^ n2));
+            i -= 1;
+            j -= 1;
+        }
+        while(i >= 0){
+            int n1 = a.charAt(i) - '0';
+            result = String.valueOf(n1^carry) + result;
+            carry &= n1;
+            i -= 1;
+        }
+        while(j >= 0){
+            int n2 = b.charAt(j) - '0';
+            result = String.valueOf(n2^carry) + result;
+            carry &= n2;
+            j -= 1;
+        }
+        if(carry==1){
+            result = '1' + result;
+        }
+        return result;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Mathematics/ExcelSheet.java b/Sowmya/Mathematics/ExcelSheet.java
new file mode 100644
index 0000000..9b68266
--- /dev/null
+++ b/Sowmya/Mathematics/ExcelSheet.java
@@ -0,0 +1,17 @@
+class ExcelSheet {
+    public String convertToTitle(int columnNumber) {
+        StringBuffer result = new StringBuffer();
+        while(columnNumber > 26){
+            int rem = columnNumber % 26;
+            if(rem==0){
+                rem += 26;
+                columnNumber -= 1;
+            }
+            result.append((char)(rem + 64));
+            columnNumber /= 26;
+        }
+        result.append((char)(columnNumber + 64));
+        result.reverse();
+        return result.toString();
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Mathematics/Happy.java b/Sowmya/Mathematics/Happy.java
new file mode 100644
index 0000000..0fe4700
--- /dev/null
+++ b/Sowmya/Mathematics/Happy.java
@@ -0,0 +1,20 @@
+import java.util.*;
+class Happy {
+    public boolean isHappy(int n) {
+        HashSet <Integer> happy = new HashSet <Integer>();
+        while((n!=1)&&(!happy.contains(n))){
+            happy.add(n);
+            int sum = 0;
+            while(n > 0){
+                int r = n%10;
+                n/=10;
+                sum += r*r;
+            }
+            n = sum;
+        }
+        if(n==1){
+            return true;
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Mathematics/KthFactor.java b/Sowmya/Mathematics/KthFactor.java
new file mode 100644
index 0000000..8174a74
--- /dev/null
+++ b/Sowmya/Mathematics/KthFactor.java
@@ -0,0 +1,15 @@
+class KthFactor {
+    public int kthFactor(int n, int k) {
+        int[] factors = new int[n];
+        int j = 0;
+        for(int i = 1; i<=n; i++){
+            if(n%i==0){
+                factors[j++] = i;
+            }
+        }
+        if(factors[k-1]==0){
+            return -1;
+        }
+        return factors[k-1];
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Mathematics/MaximumProduct.java b/Sowmya/Mathematics/MaximumProduct.java
new file mode 100644
index 0000000..98b5d3b
--- /dev/null
+++ b/Sowmya/Mathematics/MaximumProduct.java
@@ -0,0 +1,11 @@
+import java.util.*;
+class MaximumProduct {
+    public int maximumProduct(int[] nums) {
+        Arrays.sort(nums);
+        int last = nums.length - 1;
+        if(nums[last]*nums[last-1]*nums[last-2] > nums[0]*nums[1]*nums[last]){
+            return nums[last]*nums[last-1]*nums[last-2];
+        }
+        return nums[0]*nums[1]*nums[last];
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Mathematics/MinToMakeArrayEqual.java b/Sowmya/Mathematics/MinToMakeArrayEqual.java
new file mode 100644
index 0000000..2b7a63f
--- /dev/null
+++ b/Sowmya/Mathematics/MinToMakeArrayEqual.java
@@ -0,0 +1,19 @@
+class MinToMakeArrayEqual {
+    public int minMoves(int[] nums) {
+        int minimum = min(nums);
+        int sum = 0;
+        for(int i = 0; i<nums.length; i++){
+            sum += nums[i];
+        }
+        return sum - nums.length*minimum;
+    }
+    public static int min(int[] nums){
+        int m = nums[0];
+        for(int i = 1; i<nums.length; i++){
+            if(m > nums[i]){
+                m = nums[i];
+            }
+        }
+        return m;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Mathematics/Missing.java b/Sowmya/Mathematics/Missing.java
new file mode 100644
index 0000000..609f7a6
--- /dev/null
+++ b/Sowmya/Mathematics/Missing.java
@@ -0,0 +1,15 @@
+class Missing {
+    public int missingNumber(int[] nums) {
+        int n = nums.length;
+        int total = sum(nums);
+        int actual_total = n*(n+1)/2;
+        return actual_total - total;
+    }
+    public static int sum(int[] nums){
+        int s = 0;
+        for(int i = 0; i<nums.length; i++){
+            s += nums[i];
+        }
+        return s;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Mathematics/Palindrome.java b/Sowmya/Mathematics/Palindrome.java
new file mode 100644
index 0000000..e8ede7f
--- /dev/null
+++ b/Sowmya/Mathematics/Palindrome.java
@@ -0,0 +1,15 @@
+class Palindrome {
+    public boolean isPalindrome(int x) {
+        int rev = 0;
+        int n = x;
+        while(n>0){
+            rev *= 10;
+            rev += n%10;
+            n /= 10;
+        }
+        if(rev == x){
+            return true;
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Mathematics/Power2.java b/Sowmya/Mathematics/Power2.java
new file mode 100644
index 0000000..4c18c5f
--- /dev/null
+++ b/Sowmya/Mathematics/Power2.java
@@ -0,0 +1,11 @@
+class Power2 {
+    public boolean isPowerOfTwo(int n) {
+        if(n>=1){
+            if((n&(n-1))==0){
+                return true;
+            }
+            return false;
+        }
+        return false;
+    }
+}
\ No newline at end of file
diff --git a/Sowmya/Mathematics/ReverseInt.java b/Sowmya/Mathematics/ReverseInt.java
new file mode 100644
index 0000000..0cdbbdb
--- /dev/null
+++ b/Sowmya/Mathematics/ReverseInt.java
@@ -0,0 +1,22 @@
+class ReverseInt {
+    public int reverse(int x) {
+        int max = Integer.MAX_VALUE;
+        int min = Integer.MIN_VALUE;
+        long rev = 0;
+        int sign = 1;
+        if(x < 0){
+            sign = -1;
+        }
+        x = Math.abs(x);
+        while(x > 0){
+            int r = x%10;
+            x/=10;
+            rev*=10;
+            rev += r;
+            if((rev < min) || (rev > max)){
+                return 0;
+            }
+        }
+        return sign*(int)rev;
+    }
+}
\ No newline at end of file