diff --git a/Add Two Numbers.java b/Add Two Numbers.java
new file mode 100644
index 0000000000..2a5b96c1b1
--- /dev/null
+++ b/Add Two Numbers.java	
@@ -0,0 +1,22 @@
+class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        ListNode dummy = new ListNode();
+        ListNode cur=dummy;
+        int carry=0;
+        while(l1!=null || l2!=null || carry!=0){
+            int sum=carry;
+            if(l1!=null){
+                sum +=l1.val;
+                l1=l1.next;
+            }
+            if (l2 != null) {
+                sum += l2.val;
+                l2 = l2.next;
+            }
+            carry = sum / 10;
+            cur.next = new ListNode(sum % 10);
+            cur = cur.next;
+        }
+        return dummy.next;
+    }
+}
diff --git a/C++/Combination Sum.cpp b/C++/Combination Sum.cpp
new file mode 100644
index 0000000000..6c9ffc221d
--- /dev/null
+++ b/C++/Combination Sum.cpp	
@@ -0,0 +1,49 @@
+#include<vector>
+#include<stdio.h>
+
+class Solution {
+
+    public:
+    
+        vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
+    
+            vector<vector<int>> res;
+    
+            vector<int> comb;
+    
+            makeCombination(candidates, target, 0, comb, 0, res);
+    
+            return res;        
+    
+        }
+    
+    private:
+    
+        void makeCombination(std::vector<int>& candidates, int target, int idx, vector<int>& comb, int total, vector<vector<int>>& res) {
+    
+            if (total == target) {
+    
+                res.push_back(comb);
+    
+                return;
+    
+            }
+    
+            if (total > target || idx >= candidates.size()) {
+    
+                return;
+    
+            }
+    
+            comb.push_back(candidates[idx]);
+    
+            makeCombination(candidates, target, idx, comb, total + candidates[idx], res);
+    
+            comb.pop_back();
+    
+            makeCombination(candidates, target, idx + 1, comb, total, res);
+    
+        }    
+    
+    };
+    
\ No newline at end of file
diff --git a/C++/Diameter of a Binary Tree.cpp b/C++/Diameter of a Binary Tree.cpp
new file mode 100644
index 0000000000..1fd2b037d2
--- /dev/null
+++ b/C++/Diameter of a Binary Tree.cpp	
@@ -0,0 +1,17 @@
+class Solution {
+    public: 
+    int ans=0;
+    int height(TreeNode* root){
+        if(root==NULL){
+            return 0;
+        }
+        int leftHt= height(root->left);
+        int rightHt= height(root->right);
+        ans=max(leftHt+rightHt,ans);
+        return max(leftHt,rightHt)+1;
+    }
+        int diameterOfBinaryTree(TreeNode* root) { 
+            height(root);
+            return ans;
+        }
+    };
\ No newline at end of file
diff --git a/C++/Lowest Common Ancestor of a Binary Tree.cpp b/C++/Lowest Common Ancestor of a Binary Tree.cpp
new file mode 100644
index 0000000000..f63c8b6a3b
--- /dev/null
+++ b/C++/Lowest Common Ancestor of a Binary Tree.cpp	
@@ -0,0 +1,32 @@
+/*
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+*/
+class Solution {
+    public:
+        TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+          if(root==NULL){
+            return NULL;
+          }
+          if(root->val==p->val || root->val==q->val){
+            return root;
+          }
+          TreeNode* leftLCA=lowestCommonAncestor(root->left,p,q);
+          TreeNode* rightLCA=lowestCommonAncestor(root->right,p,q);
+          if(leftLCA && rightLCA)
+          {
+            return root;
+          }
+          else if(leftLCA!=NULL){
+            return leftLCA;
+          }
+          else{
+            return rightLCA;
+          }
+        }
+    };
\ No newline at end of file
diff --git a/C++/Palindrome Number.cpp b/C++/Palindrome Number.cpp
new file mode 100644
index 0000000000..40a8b56aad
--- /dev/null
+++ b/C++/Palindrome Number.cpp	
@@ -0,0 +1,25 @@
+class Solution {
+public:
+        int reverse(int x){
+        int revNum=0;
+        while(x!=0)
+        {
+            int dig=x%10;
+            if(revNum>INT_MAX/10 || revNum<INT_MIN/10)
+            {
+                return 0;
+            }
+            revNum=revNum*10+dig;
+            x=x/10;
+        }
+        return revNum;
+    }
+     bool isPalindrome(int x) {
+        if(x<0)
+        {
+            return false;
+        }
+        int revNum=reverse(x);
+        return x==revNum;
+    }
+};
diff --git a/C++/Roman To Integer.cpp b/C++/Roman To Integer.cpp
new file mode 100644
index 0000000000..2ff259aab2
--- /dev/null
+++ b/C++/Roman To Integer.cpp	
@@ -0,0 +1,27 @@
+class Solution {
+public:
+    int char2num(char a) {
+        switch (a) {
+            case 'I': return 1;
+            case 'V': return 5;
+            case 'X': return 10;
+            case 'L': return 50;
+            case 'C': return 100;
+            case 'D': return 500;
+            case 'M': return 1000;
+            default: return 0;
+        }
+    }
+
+    int romanToInt(string s) {
+        int result = 0;
+        for (int i = 0; i < s.length(); i++) {
+            if (i + 1 < s.length() && char2num(s[i]) < char2num(s[i + 1])) {
+                result -= char2num(s[i]);
+            } else {
+                result += char2num(s[i]);
+            }
+        }
+        return result;
+    }
+};
diff --git a/C++/Zigzag Conversion b/C++/Zigzag Conversion
new file mode 100644
index 0000000000..4b4d073fa8
--- /dev/null
+++ b/C++/Zigzag Conversion	
@@ -0,0 +1,33 @@
+
+
+class Solution {
+public:
+
+    string convert(string s, int numRows) {
+    
+    if(numRows <= 1) return s;
+
+    vector<string>v(numRows, ""); 
+
+    int j = 0, dir = -1;
+
+    for(int i = 0; i < s.length(); i++)
+    {
+
+        if(j == numRows - 1 || j == 0) dir *= (-1); 
+		 
+        v[j] += s[i];
+
+        if(dir == 1) j++;
+
+        else j--;
+    }
+
+    string res;
+
+    for(auto &it : v) res += it; 
+
+    return res;
+
+    }
+};
diff --git a/Count Number of Balanced Permutation.java b/Count Number of Balanced Permutation.java
new file mode 100644
index 0000000000..c05bf18993
--- /dev/null
+++ b/Count Number of Balanced Permutation.java	
@@ -0,0 +1,69 @@
+class Solution {
+
+    private static final long MOD = 1_000_000_007;
+
+    public int countBalancedPermutations(String num) {
+        int tot = 0, n = num.length();
+        int[] cnt = new int[10];
+        for (char ch : num.toCharArray()) {
+            int d = ch - '0';
+            cnt[d]++;
+            tot += d;
+        }
+        if (tot % 2 != 0) {
+            return 0;
+        }
+
+        int target = tot / 2;
+        int maxOdd = (n + 1) / 2;
+        long[][] comb = new long[maxOdd + 1][maxOdd + 1];
+        long[][] f = new long[target + 1][maxOdd + 1];
+
+        for (int i = 0; i <= maxOdd; i++) {
+            comb[i][i] = comb[i][0] = 1;
+            for (int j = 1; j < i; j++) {
+                comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % MOD;
+            }
+        }
+
+        f[0][0] = 1;
+        int psum = 0, totSum = 0;
+        for (int i = 0; i <= 9; i++) {
+            /* Sum of the number of the first i digits */
+            psum += cnt[i];
+            /* Sum of the first i numbers */
+            totSum += i * cnt[i];
+            for (
+                int oddCnt = Math.min(psum, maxOdd);
+                oddCnt >= Math.max(0, psum - (n - maxOdd));
+                oddCnt--
+            ) {
+                /* The number of bits that need to be filled in even numbered positions */
+                int evenCnt = psum - oddCnt;
+                for (
+                    int curr = Math.min(totSum, target);
+                    curr >= Math.max(0, totSum - target);
+                    curr--
+                ) {
+                    long res = 0;
+                    for (
+                        int j = Math.max(0, cnt[i] - evenCnt);
+                        j <= Math.min(cnt[i], oddCnt) && i * j <= curr;
+                        j++
+                    ) {
+                        /* The current digit is filled with j positions at odd positions, and cnt[i] - j positions at even positions */
+                        long ways =
+                            (comb[oddCnt][j] * comb[evenCnt][cnt[i] - j]) % MOD;
+                        res =
+                            (res +
+                                ((ways * f[curr - i * j][oddCnt - j]) % MOD)) %
+                            MOD;
+                    }
+                    f[curr][oddCnt] = res % MOD;
+                }
+            }
+        }
+
+        return (int) f[target][maxOdd];
+    }
+}
diff --git a/Divisible And Non-divisible Sum Differences.java b/Divisible And Non-divisible Sum Differences.java
new file mode 100644
index 0000000000..6e63287990
--- /dev/null
+++ b/Divisible And Non-divisible Sum Differences.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public int differenceOfSums(int n, int m) {
+        int ans=0;
+        for(int i=1;i<=n;i++){
+            if(i % m ==0){
+                ans-=i;
+            }else{
+                ans+=i;
+            }
+        }
+        return ans;
+    }
+}
diff --git a/Find Words Containing Character.java b/Find Words Containing Character.java
new file mode 100644
index 0000000000..6d5cbed9ca
--- /dev/null
+++ b/Find Words Containing Character.java	
@@ -0,0 +1,13 @@
+class Solution {
+    public List<Integer> findWordsContaining(String[] words, char x) {
+        List<Integer> res=new ArrayList<>();
+        int n=words.length;
+        for(int i=0;i<n;i++)
+        {
+            if(words[i].indexOf(x)!=-1){
+                res.add(i);
+            }
+        }
+        return res;
+    }
+}
diff --git a/Java/.project b/Java/.project
index 4fdb69a93e..25e31c01ff 100644
--- a/Java/.project
+++ b/Java/.project
@@ -14,4 +14,18 @@
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
+	<filteredResources>
+		<filter>
+		
+
+			<id>1744612223460</id>
+
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
 </projectDescription>
diff --git a/Java/Build Array from Permutation.java b/Java/Build Array from Permutation.java
new file mode 100644
index 0000000000..d1c56f7581
--- /dev/null
+++ b/Java/Build Array from Permutation.java	
@@ -0,0 +1,11 @@
+class Solution {
+
+    public int[] buildArray(int[] nums) {
+        int n = nums.length;
+        int[] ans = new int[n];
+        for (int i = 0; i < n; ++i) {
+            ans[i] = nums[nums[i]];
+        }
+        return ans;
+    }
+}
diff --git a/Java/Candy.java b/Java/Candy.java
new file mode 100644
index 0000000000..2c29a5df20
--- /dev/null
+++ b/Java/Candy.java
@@ -0,0 +1,29 @@
+class Solution {
+    public int candy(int[] ratings) {
+        int n = ratings.length;
+        int[] cand = new int[n];
+        Arrays.fill(cand, 1); // Step 1: Each child gets at least one candy
+
+        // Step 2: Left to right pass
+        for (int i = 1; i < n; i++) {
+            if (ratings[i] > ratings[i - 1]) {
+                cand[i] = cand[i - 1] + 1;
+            }
+        }
+
+        // Step 3: Right to left pass
+        for (int i = n - 2; i >= 0; i--) {
+            if (ratings[i] > ratings[i + 1] && cand[i] <= cand[i + 1]) {
+                cand[i] = cand[i + 1] + 1;
+            }
+        }
+
+        // Step 4: Sum all candies
+        int ans = 0;
+        for (int c : cand) {
+            ans += c;
+        }
+
+        return ans;
+    }
+}
diff --git a/Java/Count Equal and Divisible in an Array.java b/Java/Count Equal and Divisible in an Array.java
new file mode 100644
index 0000000000..22d9f82330
--- /dev/null
+++ b/Java/Count Equal and Divisible in an Array.java	
@@ -0,0 +1,17 @@
+class Solution {
+    public int countPairs(int[] nums, int k) {
+        int n=nums.length;
+        int res=0;
+        for(int i=0;i<n-1;++i)
+        {
+            for(int j=i+1;j<n;++j)
+            {
+                if((i*j)%k==0 && nums[i]==nums[j])
+                {
+                    ++res;
+                }
+            }
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/Java/Count Hidden Sequence.java b/Java/Count Hidden Sequence.java
new file mode 100644
index 0000000000..c398d16df7
--- /dev/null
+++ b/Java/Count Hidden Sequence.java	
@@ -0,0 +1,19 @@
+public  class Solution {
+    public int numberOfArrays(int[] differences, int lower, int upper) {
+        int n = differences.length;
+        int prefix = 0;
+        int min = 0;
+        int max = 0;
+        int diff = upper-lower;
+        
+        for(int i = 0;i<n;i++){
+            prefix = prefix + differences[i];
+            min = Math.min(min,prefix);
+            max = Math.max(max,prefix);
+            if(max-min > diff) return 0;
+        }
+        return (diff) - (max -min) +1;
+    }
+} 
+    
+
diff --git a/Java/Count Largest Group.java b/Java/Count Largest Group.java
new file mode 100644
index 0000000000..30507221a2
--- /dev/null
+++ b/Java/Count Largest Group.java	
@@ -0,0 +1,26 @@
+class Solution {
+    public int countLargestGroup(int n) {
+       Map<Integer, Integer>hashMap=new HashMap<Integer,Integer>();
+        int maxValue=0;
+        for(int i=1;i<=n;i++)
+        {
+            int key=0,num=i;
+            while(num!=0)
+            {
+                key+=num%10;
+                num=num/10;
+            }
+            hashMap.put(key,hashMap.getOrDefault(key,0)+1);
+            maxValue=Math.max(maxValue,hashMap.get(key));
+   }
+     int count=0;
+        for(Map.Entry<Integer,Integer>kvpair: hashMap.entrySet()){
+            if(kvpair.getValue()== maxValue)
+                {
+                ++count;
+                }
+            }
+        return count;
+                
+    }
+}
\ No newline at end of file
diff --git a/Java/Count Number of Subarrays of Length 3 within the condition.java b/Java/Count Number of Subarrays of Length 3 within the condition.java
new file mode 100644
index 0000000000..1fcbe2a495
--- /dev/null
+++ b/Java/Count Number of Subarrays of Length 3 within the condition.java	
@@ -0,0 +1,27 @@
+public class Solution 
+{
+    public int countSubarrays(int[] nums) 
+    {
+        int count = 0;
+        
+        // Step 1: Loop through the array to check subarrays of size 3
+        for (int i = 0; i <= nums.length - 3; i++) 
+        {
+            // Step 2: Extract the three consecutive elements
+            int first = nums[i];
+            int second = nums[i + 1];
+            int third = nums[i + 2];
+            
+            // Step 3: Check if 2 * (first + third) == second
+            if (2 * (first + third) == second) 
+            {
+                count++; // Increment count if condition is satisfied
+            }
+        }
+        
+        // Step 4: Return the final count of subarrays that satisfy the condition
+        return count;
+        //he.ll
+    }
+
+} 
diff --git a/Java/Count Subarray Where max element appear more than k .java b/Java/Count Subarray Where max element appear more than k .java
new file mode 100644
index 0000000000..1557a4e9d1
--- /dev/null
+++ b/Java/Count Subarray Where max element appear more than k .java	
@@ -0,0 +1,19 @@
+class Solution {
+    public long countSubarrays(int[] nums, int k) {
+        int n = nums.length;
+        int maxVal = 0;
+        for (int v : nums) maxVal = Math.max(maxVal, v);
+
+        long res = 0;
+        int count = 0, left = 0;
+        for (int right = 0; right < n; right++) {
+            if (nums[right] == maxVal) count++;
+            while (count >= k) {
+                if (nums[left] == maxVal) count--;
+                left++;
+            }
+            res += left;
+        }
+        return res;
+    }
+}
diff --git a/Java/Count and Say.java b/Java/Count and Say.java
new file mode 100644
index 0000000000..bdebba3d63
--- /dev/null
+++ b/Java/Count and Say.java	
@@ -0,0 +1,75 @@
+class Combinations {
+    long[] fact;
+    long[] invFact;
+    long M;
+
+    public Combinations(int n, long mod) {
+        M = mod;
+        fact = new long[n + 1];
+        invFact = new long[n + 1];
+        fact[0] = 1;
+        invFact[0] = 1;
+        for (int i = 1; i <= n; i++) {
+            fact[i] = (fact[i - 1] * i) % M;
+            invFact[i] = power(fact[i], M - 2);
+        }
+    }
+
+    long power(long base, long exp) {
+        long res = 1;
+        base %= M;
+        while (exp > 0) {
+            if ((exp & 1) == 1) res = (res * base) % M;
+            base = (base * base) % M;
+            exp >>= 1;
+        }
+        return res;
+    }
+
+    long nCr(int n, int r) {
+        if (r < 0 || r > n) return 0;
+        long num = fact[n];
+        long den = (invFact[r] * invFact[n - r]) % M;
+        return (num * den) % M;
+    }
+}
+
+class Solution {
+    private static final int MOD = 1_000_000_007;
+
+    public int idealArrays(int n, int maxValue) {
+        Combinations comb = new Combinations(n, MOD);
+        long[] dp = new long[maxValue + 1];
+        long totalAns = maxValue;
+
+        for (int i = 1; i <= maxValue; i++) {
+            dp[i] = 1;
+        }
+
+        int kLimit = Math.min(n, 16);
+
+        for (int k = 2; k <= kLimit; k++) {
+            long[] next_dp = new long[maxValue + 1];
+            for (int j = 1; j <= maxValue; j++) {
+                if (dp[j] == 0) continue;
+                for (long i = 2L * j; i <= maxValue; i += j) {
+                    next_dp[(int) i] = (next_dp[(int) i] + dp[j]) % MOD;
+                }
+            }
+
+            long count = 0;
+            for (int i = 1; i <= maxValue; i++) {
+                count = (count + next_dp[i]) % MOD;
+            }
+
+            if (count == 0) break;
+
+            long factor = comb.nCr(n - 1, k - 1);
+            totalAns = (totalAns + count * factor % MOD) % MOD;
+
+            dp = next_dp;
+        }
+
+        return (int) totalAns;
+    }
+}
\ No newline at end of file
diff --git a/Java/Count of Good Subarray.java b/Java/Count of Good Subarray.java
new file mode 100644
index 0000000000..da19d185c5
--- /dev/null
+++ b/Java/Count of Good Subarray.java	
@@ -0,0 +1,22 @@
+public class Solution {
+
+    public long countGood(int[] nums, int k) {
+        int n = nums.length;
+        int same = 0, right = -1;
+        HashMap<Integer, Integer> cnt = new HashMap<>();
+        long ans = 0;
+        for (int left = 0; left < n; ++left) {
+            while (same < k && right + 1 < n) {
+                ++right;
+                same += cnt.getOrDefault(nums[right], 0);
+                cnt.put(nums[right], cnt.getOrDefault(nums[right], 0) + 1);
+            }
+            if (same >= k) {
+                ans += n - right;
+            }
+            cnt.put(nums[left], cnt.get(nums[left]) - 1);
+            same -= cnt.get(nums[left]);
+        }
+        return ans;
+    }
+} 
diff --git a/Java/Count of Interested Subarrays.java b/Java/Count of Interested Subarrays.java
new file mode 100644
index 0000000000..5f904d73fd
--- /dev/null
+++ b/Java/Count of Interested Subarrays.java	
@@ -0,0 +1,32 @@
+class Solution 
+{
+    public long countInterestingSubarrays(List<Integer> nums, int modulo, int k) 
+    {
+        // Step 1 : Initialize result, prefix sum, and a map with base case
+        long result = 0;
+        int prefix = 0;
+        Map<Integer, Long> map = new HashMap<>();
+        map.put(0, 1L);
+
+        // Step 2 : Traverse through nums
+        for (int num : nums) 
+        {
+            // Step 3 : Check condition and update prefix
+            if (num % modulo == k) 
+            {
+                prefix++;
+            }
+
+            // Step 4 : Calculate current prefix mod and target
+            int mod = prefix % modulo;
+            int target = (mod - k + modulo) % modulo;
+
+            // Step 5 : Add to result and update map
+            result += map.getOrDefault(target, 0L);
+            map.put(mod, map.getOrDefault(mod, 0L) + 1);
+        }
+
+        // Step 6 : Return final count
+        return result;
+    }
+}
diff --git a/Java/Count of Subarray with Score less than k.java b/Java/Count of Subarray with Score less than k.java
new file mode 100644
index 0000000000..9536523b93
--- /dev/null
+++ b/Java/Count of Subarray with Score less than k.java	
@@ -0,0 +1,15 @@
+class Solution {
+    public long countSubarrays(int[] nums, long k) {
+           int n=nums.length;
+        long res=0,total=0;
+        for(int i=0,j=0;j<n;j++){
+            total+=nums[j];
+            while(i<=j && total*(j-i+1)>=k){
+                total-=nums[i];
+                i++;
+            }
+            res+=j-i+1;
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git a/Java/Count of Subarrays in An Array.java b/Java/Count of Subarrays in An Array.java
new file mode 100644
index 0000000000..5032b24ab9
--- /dev/null
+++ b/Java/Count of Subarrays in An Array.java	
@@ -0,0 +1,28 @@
+class Solution {
+    public int countCompleteSubarrays(int[] nums) {
+        int cnt = 0;
+        HashSet<Integer> set = new HashSet<>();
+        for (int i = 0; i < nums.length; i++) {
+            set.add(nums[i]);
+        }
+        HashMap<Integer, Integer> map = new HashMap<>();
+        int i = 0, j = 0;
+        while (j < nums.length) {
+            map.put(nums[j], map.getOrDefault(nums[j], 0) + 1);
+            if (map.size() == set.size()) {
+                cnt += nums.length - j;
+                while (true) {
+                    map.put(nums[i], map.get(nums[i]) - 1);
+                    if (map.get(nums[i]) == 0) {
+                        map.remove(nums[i++]);
+                        break;
+                    }
+                    cnt += nums.length - j;
+                    i++;
+                }
+            }
+            j++;
+        }
+        return cnt;
+    }
+}
\ No newline at end of file
diff --git a/Java/Distribute Candies Among Children II .java b/Java/Distribute Candies Among Children II .java
new file mode 100644
index 0000000000..2cd3b4f794
--- /dev/null
+++ b/Java/Distribute Candies Among Children II .java	
@@ -0,0 +1,14 @@
+class Solution {
+    public long distributeCandies(int n, int limit) {
+        java.util.function.LongUnaryOperator C2 = x -> (x >= 2) ? (x * (x - 1) / 2) : 0L;
+        long N = n, L = limit;
+        long total = (N + 2) * (N + 1) / 2;
+        long x1 = N - L + 1; 
+        long t1 = C2.applyAsLong(x1);
+        long x2 = N - 2 * L;
+        long t2 = C2.applyAsLong(x2);
+        long x3 = N - 3 * L - 1;
+        long t3 = C2.applyAsLong(x3);
+        return total - 3 * t1 + 3 * t2 - t3;
+    }
+}
diff --git a/Java/Divide Two Integers.java b/Java/Divide Two Integers.java
new file mode 100644
index 0000000000..dc074a186b
--- /dev/null
+++ b/Java/Divide Two Integers.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public int divide(int dividend, int divisor) {
+        if (divisor == 1) {
+            return dividend;
+        }
+        if (dividend == Integer.MIN_VALUE && divisor == -1) {
+            return Integer.MAX_VALUE;
+        }
+        boolean sign = (dividend> 0 && divisor > 0) || (dividend< 0 && divisor< 0);
+        dividend= dividend > 0 ? -dividend : dividend;
+        divisor = divisor > 0 ? -divisor : divisor;
+        int ans = 0;
+        while (dividend <= divisor) {
+            int x = divisor;
+            int cnt = 1;
+            while (x >= (Integer.MIN_VALUE >> 1) && dividend <= (x << 1)) {
+                x <<= 1;
+                cnt <<= 1;
+            }
+            ans += cnt;
+            dividend-= x;
+        }
+        return sign ? ans : -ans;
+    }
+}
diff --git a/Java/Domino and Tromino Tiling.java b/Java/Domino and Tromino Tiling.java
new file mode 100644
index 0000000000..971539563e
--- /dev/null
+++ b/Java/Domino and Tromino Tiling.java	
@@ -0,0 +1,26 @@
+#include<stdio.h>
+
+public class Solution {
+    public:
+        const int MOD = 1e9 + 7;
+        template <typename T>
+        inline T mod_add(T a, T b, T m) { return (a % m + b % m) % m; }
+        vector<int> dp;
+        int rec(int idx) {
+            if (idx == 0) return 1;
+            if (idx == 1) return 1;
+            if (idx == 2) return 2;
+            if (dp[idx] != -1) return dp[idx];
+            auto ans = (2LL * rec(idx - 1)) % MOD;
+            ans = mod_add<long long>(ans, rec(idx - 3), MOD);
+            
+            return dp[idx] = ans;
+        }
+    
+    
+        int numTilings(int n) {
+            dp.assign(n + 1, -1);
+            return rec(n);
+        }
+    };
+
diff --git a/Java/Find Minimum time to reach the last Room I.java b/Java/Find Minimum time to reach the last Room I.java
new file mode 100644
index 0000000000..b340e8113c
--- /dev/null
+++ b/Java/Find Minimum time to reach the last Room I.java	
@@ -0,0 +1,55 @@
+class Solution {
+
+    private static final int INF = 0x3f3f3f3f;
+
+    public int minTimeToReach(int[][] moveTime) {
+        int n = moveTime.length, m = moveTime[0].length;
+        int[][] d = new int[n][m];
+        boolean[][] v = new boolean[n][m];
+        for (int i = 0; i < n; i++) {
+            Arrays.fill(d[i], INF);
+        }
+
+        int[][] dirs = { { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 } };
+        d[0][0] = 0;
+        PriorityQueue<State> q = new PriorityQueue<>();
+        q.offer(new State(0, 0, 0));
+
+        while (!q.isEmpty()) {
+            State s = q.poll();
+            if (v[s.x][s.y]) {
+                continue;
+            }
+            v[s.x][s.y] = true;
+            for (int[] dir : dirs) {
+                int nx = s.x + dir[0];
+                int ny = s.y + dir[1];
+                if (nx < 0 || nx >= n || ny < 0 || ny >= m) {
+                    continue;
+                }
+                int dist = Math.max(d[s.x][s.y], moveTime[nx][ny]) + 1;
+                if (d[nx][ny] > dist) {
+                    d[nx][ny] = dist;
+                    q.offer(new State(nx, ny, dist));
+                }
+            }
+        }
+        return d[n - 1][m - 1];
+    }
+
+    static class State implements Comparable<State> {
+
+        int x, y, dis;
+
+        State(int x, int y, int dis) {
+            this.x = x;
+            this.y = y;
+            this.dis = dis;
+        }
+
+        @Override
+        public int compareTo(State other) {
+            return Integer.compare(this.dis, other.dis);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Java/Find Minimum time to reach the last room II.java b/Java/Find Minimum time to reach the last room II.java
new file mode 100644
index 0000000000..d04ab7516d
--- /dev/null
+++ b/Java/Find Minimum time to reach the last room II.java	
@@ -0,0 +1,72 @@
+import java.util.*;
+
+public class Solution {
+
+    public int minTimeToReach(int[][] moveTime) {
+
+        int n = moveTime.length;
+
+        int m = moveTime[0].length;
+
+        int[][] bestTime = new int[n][m];
+
+        for (int[] row : bestTime) {
+
+            Arrays.fill(row, Integer.MAX_VALUE);
+
+        }
+
+        int[][] directions = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
+
+        PriorityQueue<int[]> pq = new PriorityQueue<>(Comparator.comparingInt(a -> a[0]));
+
+        pq.offer(new int[]{0, 0, 0, 0}); // time, i, j, nextMoveTime
+
+        while (!pq.isEmpty()) {
+
+            int[] curr = pq.poll();
+
+            int time = curr[0], i = curr[1], j = curr[2], nextMoveTime = curr[3];
+
+            if (time >= bestTime[i][j]) continue;
+
+            bestTime[i][j] = time;
+
+            if (i == n - 1 && j == m - 1) return time;
+
+            for (int[] d : directions) {
+
+                int x = i + d[0], y = j + d[1];
+
+                if (x >= 0 && x < n && y >= 0 && y < m) {
+
+                    int wait = moveTime[x][y];
+
+                    int futureMove = nextMoveTime == 1 ? 2 : 1;
+
+                    int nextTime = wait > time ? wait + futureMove : time + futureMove;
+
+                    if (i == 0 && j == 0 && wait <= time) {
+
+                        nextTime = wait + futureMove;
+
+                    }
+
+                    if (nextTime < bestTime[x][y]) {
+
+                        pq.offer(new int[]{nextTime, x, y, futureMove});
+
+                    }
+
+                }
+
+            }
+
+        }
+
+        return -1; // Should never reach
+
+    }
+
+}
+    
diff --git a/Java/Find Numbers with Even Numbers of Digits.java b/Java/Find Numbers with Even Numbers of Digits.java
new file mode 100644
index 0000000000..abe01753f6
--- /dev/null
+++ b/Java/Find Numbers with Even Numbers of Digits.java	
@@ -0,0 +1,23 @@
+class Solution {
+    // Helper function to check if the number of digits is even
+    private boolean hasEvenDigits(int num) {
+        int digitCount = 0;
+        while (num != 0) {
+            digitCount++;
+            num /= 10;
+        }
+        return (digitCount & 1) == 0;
+    }
+
+    public int findNumbers(int[] nums) {
+        // Counter to count the number of even digit integers
+        int evenDigitCount = 0;
+
+        for (int num : nums) {
+            if (hasEvenDigits(num))
+                evenDigitCount++;
+        }
+
+        return evenDigitCount;
+    }
+}
diff --git a/Java/Find the Lexicographically Largest string from the box .java b/Java/Find the Lexicographically Largest string from the box .java
new file mode 100644
index 0000000000..24e571c0f6
--- /dev/null
+++ b/Java/Find the Lexicographically Largest string from the box .java	
@@ -0,0 +1,17 @@
+class Solution {
+
+    public String answerString(String word, int numFriends) {
+        if (numFriends == 1) {
+            return word;
+        }
+        int n = word.length();
+        String res = "";
+        for (int i = 0; i < n; i++) {
+            String s = word.substring(i, Math.min(i + n - numFriends + 1, n));
+            if (res.compareTo(s) <= 0) {
+                res = s;
+            }
+        }
+        return res;
+    }
+}
diff --git a/Java/Longest Palindromic Substring.java b/Java/Longest Palindromic Substring.java
new file mode 100644
index 0000000000..a7b19c40bd
--- /dev/null
+++ b/Java/Longest Palindromic Substring.java	
@@ -0,0 +1,36 @@
+public class Solution {
+    public String longestPalindrome(String s) {
+        if (s.length() <= 1) {
+            return s;
+        }
+
+        int maxLen = 1;
+        String maxStr = s.substring(0, 1);
+
+        for (int i = 0; i < s.length(); i++) {
+            for (int j = i + maxLen; j <= s.length(); j++) {
+                if (j - i > maxLen && isPalindrome(s.substring(i, j))) {
+                    maxLen = j - i;
+                    maxStr = s.substring(i, j);
+                }
+            }
+        }
+
+        return maxStr;
+    }
+
+    private boolean isPalindrome(String str) {
+        int left = 0;
+        int right = str.length() - 1;
+
+        while (left < right) {
+            if (str.charAt(left) != str.charAt(right)) {
+                return false;
+            }
+            left++;
+            right--;
+        }
+
+        return true;
+    }
+}
diff --git a/Java/Maximum Value of an  Ordered Triplets.java b/Java/Maximum Value of an  Ordered Triplets.java
new file mode 100644
index 0000000000..1453d1b089
--- /dev/null
+++ b/Java/Maximum Value of an  Ordered Triplets.java	
@@ -0,0 +1,30 @@
+ //TC:O(N)
+ //SC:O(N)
+
+class Solution {
+    public long maximumTripletValue(int[]  nums){
+        int n = nums.length;
+        if (n < 3) return 0;
+
+        int[] leftMax = new int[n];
+        leftMax[0] = nums[0];
+        for (int i = 1; i < n; i++) {
+            leftMax[i] = Math.max(leftMax[i - 1], nums[i]);
+        }
+
+        int[] rightMax = new int[n];
+        rightMax[n - 1] = nums[n - 1];
+        for (int i = n - 2; i >= 0; i--) {
+            rightMax[i] = Math.max(rightMax[i + 1], nums[i]);
+        }
+
+        long ans = 0;  
+        for (int i = 1; i < n - 1; i++) {
+            int left = leftMax[i - 1];
+            int right = rightMax[i + 1];
+            ans = Math.max(ans, (long)(left - nums[i]) * right); 
+        }
+
+        return ans;
+    }
+}
\ No newline at end of file
diff --git a/Java/Minimum Dominaeo Rotation for Equal row.java b/Java/Minimum Dominaeo Rotation for Equal row.java
new file mode 100644
index 0000000000..eba0c9432a
--- /dev/null
+++ b/Java/Minimum Dominaeo Rotation for Equal row.java	
@@ -0,0 +1,47 @@
+class Solution 
+{
+    public int minDominoRotations(int[] tops, int[] bottoms) 
+    {
+        // Step 1: Try to make all values equal to tops[0]
+        int result = check(tops[0], tops, bottoms);
+
+        // Step 2: If tops[0] failed, try bottoms[0]
+        if (result != -1) return result;
+
+        // Step 3: Return result from checking bottoms[0]
+        return check(bottoms[0], tops, bottoms);
+    }
+
+    // Step 4: Helper function to count rotations to make all values = target
+    private int check(int target, int[] tops, int[] bottoms) 
+    {
+        int rotateTop = 0;    // Rotations needed to bring target to top
+        int rotateBottom = 0; // Rotations needed to bring target to bottom
+
+        // Step 5: Loop through all dominoes
+        for (int i = 0; i < tops.length; i++) 
+        {
+            // Step 6: If target is not on either side, it's impossible
+            if (tops[i] != target && bottoms[i] != target) 
+            {
+                return -1;
+            }
+
+            // Step 7: If top doesn't have the target, it must be rotated
+            if (tops[i] != target)
+            {
+                rotateTop++;
+            } 
+
+            // Step 8: If bottom doesn't have the target, it must be rotated
+            if (bottoms[i] != target)
+            {
+                rotateBottom++;
+            } 
+        }
+
+        // Step 9: Return the minimum of the two rotation counts
+        return Math.min(rotateTop, rotateBottom);
+    }
+}
+    
\ No newline at end of file
diff --git a/Java/Reverse Integer . java b/Java/Reverse Integer . java
new file mode 100644
index 0000000000..da0fe250b1
--- /dev/null
+++ b/Java/Reverse Integer . java	
@@ -0,0 +1,16 @@
+class Solution {
+    public int reverse(int x) {
+        int ans = 0;
+        while(x != 0){
+            int rem = x % 10;
+            if(ans < Integer.MIN_VALUE/10 || ans > Integer.MAX_VALUE/10)
+                return 0;
+            ans = (ans*10) + rem;
+            x = x/10;
+
+        }
+
+        return ans;
+
+    }
+}
diff --git a/Java/Snakes And Ladders.java b/Java/Snakes And Ladders.java
new file mode 100644
index 0000000000..7910770562
--- /dev/null
+++ b/Java/Snakes And Ladders.java	
@@ -0,0 +1,48 @@
+class Solution {
+    public int snakesAndLadders(int[][] board) {
+        int n = board.length;
+        boolean[] visited = new boolean[n * n + 1];
+        Queue<int[]> queue = new LinkedList<>();
+        queue.offer(new int[]{1, 0}); // {square number, number of moves}
+        visited[1] = true;
+
+        while (!queue.isEmpty()) {
+            int[] curr = queue.poll();
+            int square = curr[0];
+            int moves = curr[1];
+
+            for (int i = 1; i <= 6; i++) {
+                int next = square + i;
+                if (next > n * n) continue;
+
+                int[] pos = getCoordinates(next, n);
+                int r = pos[0], c = pos[1];
+
+                if (board[r][c] != -1) {
+                    next = board[r][c];
+                }
+
+                if (next == n * n) {
+                    return moves + 1;
+                }
+
+                if (!visited[next]) {
+                    visited[next] = true;
+                    queue.offer(new int[]{next, moves + 1});
+                }
+            }
+        }
+
+        return -1; // unreachable
+    }
+
+    // Converts 1-based square number to (row, col) in board
+    private int[] getCoordinates(int num, int n) {
+        int r = (n - 1) - (num - 1) / n;
+        int c = (num - 1) % n;
+        if (((n - 1 - r) % 2) == 1) {
+            c = n - 1 - c;
+        }
+        return new int[]{r, c};
+    }
+}
diff --git a/Java/Zero Array Transformation.java b/Java/Zero Array Transformation.java
new file mode 100644
index 0000000000..76e5ea4653
--- /dev/null
+++ b/Java/Zero Array Transformation.java	
@@ -0,0 +1,32 @@
+class Solution {
+    public static int maxRemoval(int[] nums, int[][] queries) {
+        int n = nums.length, q = queries.length;
+        List<List<Integer>> qEnd = new ArrayList<>();
+        for (int i = 0; i < n; i++) qEnd.add(new ArrayList<>());
+        for (int[] query : queries) {
+            qEnd.get(query[0]).add(query[1]);
+        }
+
+        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
+        int[] cntQ = new int[n + 1];
+        int dec = 0;
+
+        for (int i = 0; i < n; i++) {
+            dec += cntQ[i];
+            for (int end : qEnd.get(i)) {
+                pq.offer(end);
+            }
+
+            int x = nums[i];
+            while (x > dec && !pq.isEmpty() && pq.peek() >= i) {
+                int k = pq.poll();
+                cntQ[k + 1]--;
+                dec++;
+            }
+
+            if (x > dec) return -1;
+        }
+
+        return pq.size();
+    }
+}
diff --git a/Length of String After Transformation II.java b/Length of String After Transformation II.java
new file mode 100644
index 0000000000..f2a1e660ce
--- /dev/null
+++ b/Length of String After Transformation II.java	
@@ -0,0 +1,50 @@
+class Solution {
+    private static final int mod = 1000000007;
+
+    private long[][] multiplyMatrices(long[][] A, long[][] B) {
+        int rowsA = A.length, colsA = A[0].length, colsB = B[0].length;
+        long[][] result = new long[rowsA][colsB];
+        for (int i = 0; i < rowsA; i++) {
+            for (int j = 0; j < colsB; j++) {
+                long sum = 0;
+                for (int k = 0; k < colsA; k++) {
+                    sum = (sum + (A[i][k] * B[k][j]) % mod) % mod;
+                }
+                result[i][j] = sum;
+            }
+        }
+        return result;
+    }
+
+    private long[][] powerMatrix(long[][] matrix, long exponent) {
+        int n = matrix.length;
+        long[][] result = new long[n][n];
+        for (int i = 0; i < n; i++) result[i][i] = 1;
+        while (exponent > 0) {
+            if ((exponent & 1) == 1) result = multiplyMatrices(result, matrix);
+            matrix = multiplyMatrices(matrix, matrix);
+            exponent >>= 1;
+        }
+        return result;
+    }
+
+    public int lengthAfterTransformations(String s, int t, List<Integer> nums) {
+        long[][] transform = new long[26][26];
+        for (int i = 0; i < 26; i++) {
+            for (int shift = 0; shift < nums.get(i); shift++) {
+                transform[i][(i + 1 + shift) % 26]++;
+            }
+        }
+        transform = powerMatrix(transform, t);
+        long[][] freq = new long[1][26];
+        for (char ch : s.toCharArray()) {
+            freq[0][ch - 'a']++;
+        }
+        freq = multiplyMatrices(freq, transform);
+        long total = 0;
+        for (long cnt : freq[0]) {
+            total = (total + cnt) % mod;
+        }
+        return (int)total;
+    }
+}
\ No newline at end of file
diff --git a/Length of the String After Transformation I.java b/Length of the String After Transformation I.java
new file mode 100644
index 0000000000..e088f80bd9
--- /dev/null
+++ b/Length of the String After Transformation I.java	
@@ -0,0 +1,24 @@
+class Solution {
+    public int lengthAfterTransformations(String s, int t) {
+        int MOD = 1_000_000_007;
+        int[] v = new int[26];
+        for (char ch : s.toCharArray()) {
+            v[ch - 'a']++;
+        }
+        for (int i = 0; i < t; i++) {
+            int ele = v[25];
+            for (int j = 25; j > 0; j--) {
+                v[j] = v[j - 1];
+            }
+            v[0] = 0;
+            v[0] = (v[0] + ele) % MOD;
+            v[1] = (v[1] + ele) % MOD;
+        }
+        int sum = 0;
+        for (int i = 0; i < 26; i++) {
+            sum = (sum + v[i]) % MOD;
+        }
+        return sum;
+    }
+}
+    
\ No newline at end of file
diff --git a/Longest Unequal Adjacent Groups Sequence II.java b/Longest Unequal Adjacent Groups Sequence II.java
new file mode 100644
index 0000000000..04f1d7a737
--- /dev/null
+++ b/Longest Unequal Adjacent Groups Sequence II.java	
@@ -0,0 +1,51 @@
+class Solution {
+
+    public List<String> getWordsInLongestSubsequence(
+        String[] words,
+        int[] groups
+    ) {
+        int n = groups.length;
+        int[] dp = new int[n];
+        int[] prev = new int[n];
+        Arrays.fill(dp, 1);
+        Arrays.fill(prev, -1);
+        int maxIndex = 0;
+        for (int i = 1; i < n; i++) {
+            for (int j = 0; j < i; j++) {
+                if (
+                    check(words[i], words[j]) &&
+                    dp[j] + 1 > dp[i] &&
+                    groups[i] != groups[j]
+                ) {
+                    dp[i] = dp[j] + 1;
+                    prev[i] = j;
+                }
+            }
+            if (dp[i] > dp[maxIndex]) {
+                maxIndex = i;
+            }
+        }
+        List<String> ans = new ArrayList<>();
+        for (int i = maxIndex; i >= 0; i = prev[i]) {
+            ans.add(words[i]);
+        }
+        Collections.reverse(ans);
+        return ans;
+    }
+
+    private boolean check(String s1, String s2) {
+        if (s1.length() != s2.length()) {
+            return false;
+        }
+        int diff = 0;
+        for (int i = 0; i < s1.length(); i++) {
+            if (s1.charAt(i) != s2.charAt(i)) {
+                if (++diff > 1) {
+                    return false;
+                }
+            }
+        }
+        return diff == 1;
+    }
+}
+    
diff --git a/Longest Unequal Adjacent Sequence Groups I.java b/Longest Unequal Adjacent Sequence Groups I.java
new file mode 100644
index 0000000000..e12b4df395
--- /dev/null
+++ b/Longest Unequal Adjacent Sequence Groups I.java	
@@ -0,0 +1,39 @@
+public class class Solution {
+
+    public List<String> getLongestSubsequence(String[] words, int[] groups) {
+        int n = words.length;
+        int[] dp = new int[n];
+        int[] prev = new int[n];
+        int maxLen = 1, endIndex = 0;
+
+        for (int i = 0; i < n; i++) {
+            dp[i] = 1;
+            prev[i] = -1;
+        }
+        for (int i = 1; i < n; i++) {
+            int bestLen = 1;
+            int bestPrev = -1;
+            for (int j = i - 1; j >= 0; j--) {
+                if (groups[i] != groups[j] && dp[j] + 1 > bestLen) {
+                    bestLen = dp[j] + 1;
+                    bestPrev = j;
+                }
+            }
+            dp[i] = bestLen;
+            prev[i] = bestPrev;
+            if (dp[i] > maxLen) {
+                maxLen = dp[i];
+                endIndex = i;
+            }
+        }
+
+        List<String> res = new ArrayList<>();
+        for (int i = endIndex; i != -1; i = prev[i]) {
+            res.add(words[i]);
+        }
+        Collections.reverse(res);
+        return res;
+    }
+}
+    
+
diff --git a/Longest palindrome by concatenating two words b/Longest palindrome by concatenating two words
new file mode 100644
index 0000000000..0b89c378c4
--- /dev/null
+++ b/Longest palindrome by concatenating two words	
@@ -0,0 +1,31 @@
+import java.util.*;
+
+class Solution {
+    public int longestPalindrome(String[] words) {
+        Map<String, Integer> map = new HashMap<>();
+        int count = 0;
+        boolean hasCentralWord = false;
+
+        for (String word : words)
+            map.put(word, map.getOrDefault(word, 0) + 1);
+
+        for (String word : map.keySet()) {
+            int freq = map.get(word);
+            if (freq == 0) continue;
+
+            String reversed = new StringBuilder(word).reverse().toString();
+            if (word.equals(reversed)) {
+                count += (freq / 2) * 4;
+                if (freq % 2 == 1) hasCentralWord = true;
+            } else if (map.containsKey(reversed)) {
+                int pairs = Math.min(freq, map.get(reversed));
+                count += pairs * 4;
+                map.put(reversed, 0);
+            }
+            map.put(word, 0);
+        }
+
+        if (hasCentralWord) count += 2;
+        return count;
+    }
+}
diff --git a/Minimum Equal Sum of Two Arrays After Replacing Zeroes.java b/Minimum Equal Sum of Two Arrays After Replacing Zeroes.java
new file mode 100644
index 0000000000..c10f60ffee
--- /dev/null
+++ b/Minimum Equal Sum of Two Arrays After Replacing Zeroes.java	
@@ -0,0 +1,29 @@
+class Solution {
+
+    public long minSum(int[] nums1, int[] nums2) {
+        long sum1 = 0, sum2 = 0;
+        long zero1 = 0, zero2 = 0;
+
+        for (int i : nums1) {
+            sum1 += i;
+            if (i == 0) {
+                sum1++;
+                zero1++;
+            }
+        }
+
+        for (int i : nums2) {
+            sum2 += i;
+            if (i == 0) {
+                sum2++;
+                zero2++;
+            }
+        }
+
+        if ((zero1 == 0 && sum2 > sum1) || (zero2 == 0 && sum1 > sum2)) {
+            return -1;
+        }
+
+        return Math.max(sum1, sum2);
+    }
+}
\ No newline at end of file
diff --git a/Painting the grid with n different colors b/Painting the grid with n different colors
new file mode 100644
index 0000000000..1826946429
--- /dev/null
+++ b/Painting the grid with n different colors	
@@ -0,0 +1,66 @@
+class Solution {
+
+    // update RGB combination as 0x7 for improvement.
+        
+    private static final int R = 1;
+    private static final int G = 2;
+    private static final int B = 4;
+    private static final int mod = (int)1e9+7;   
+    public int colorTheGrid(int m, int n) {
+
+        //compute overall number of possible permutations for a single column
+        int count = 3;
+        for(int i = 0; i  < m - 1; i++)
+            count *= 2;
+        
+        long[] perms = new long[count];
+        Queue<Integer> que = new LinkedList<>();
+                
+        que.offer(R);
+        que.offer(G);
+        que.offer(B);
+        
+        //fill in all possible permuatations using Queue
+        int index = count;
+        
+        while(!que.isEmpty()){
+            int color  = que.poll();
+            if( color >=  1 << 3 * (m-1) ) //m - length permutation
+                perms[--index] = color;
+            else{
+                
+                   int nextcolors = 0x7^ (color & 0x7);
+                   while(nextcolors > 0){
+                       int nextcolor = nextcolors &(-nextcolors);
+                       que.add((color << 3) + nextcolor);
+                       nextcolors &= (nextcolors - 1);
+                    }
+                }
+        }
+        
+        int[] cur = new int[count];
+        Arrays.fill(cur, 1);
+        
+        //iterate by columns from left to right, 
+        //memorizing score count for every permutation in current column
+        for(int col = 0; col < n-1; col++){
+            
+            int[] next = new int[count];
+
+            for(int i = 0; i < count; i++){
+                for(int j = 0; j < count; j++){
+                    if((perms[i] & perms[j]) == 0) // both are OK to each other 
+                        next[j] = (next[j] + cur[i])%mod;
+                }
+            }
+            cur = next;
+        }
+        
+        //accumulate all scores for permuttions as per last column 
+        int result = 0;
+        for(int i = 0; i < count; i++)
+            result = (result + cur[i]) % mod;
+        
+        return result;    
+    }
+}
\ No newline at end of file
diff --git a/Reverse Integer.cpp b/Reverse Integer.cpp
new file mode 100644
index 0000000000..e24130d942
--- /dev/null
+++ b/Reverse Integer.cpp	
@@ -0,0 +1,18 @@
+class Solution {
+public:
+    int reverse(int x) {
+        int ans = 0; // Initialize the reversed number to 0
+        while (x != 0) {
+            int digit = x % 10; // Get the last digit of x
+            
+            // Check for overflow/underflow before updating ans
+            if ((ans > INT_MAX / 10) || (ans < INT_MIN / 10)) {
+                return 0; // Return 0 if reversing x would cause overflow/underflow
+            }
+            
+            ans = ans * 10 + digit; // Append the digit to the reversed number
+            x = x / 10; // Remove the last digit from x
+        }
+        return ans; // Return the reversed number
+    }
+};
diff --git a/Set Zeroes Matrix.java b/Set Zeroes Matrix.java
new file mode 100644
index 0000000000..fee5785605
--- /dev/null
+++ b/Set Zeroes Matrix.java	
@@ -0,0 +1,25 @@
+class Solution {
+    public void setZeroes(int[][] matrix) {
+        int n = matrix.length;
+        int m = matrix[0].length;
+        boolean[] row = new boolean[n];
+        boolean[] col = new boolean[m];
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (matrix[i][j] == 0) {
+                    row[i] = true;
+                    col[j] = true;
+                }
+            }
+        }
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < m; j++) {
+                if (row[i] || col[j]) {
+                    matrix[i][j] = 0;
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Sort Colors b/Sort Colors
new file mode 100644
index 0000000000..52765c5c79
--- /dev/null
+++ b/Sort Colors	
@@ -0,0 +1,16 @@
+lass Solution {
+    public void sortColors(int[] nums) {
+        int [] count=new int[3];
+        for (int num:nums)
+        {
+            count[num]++;
+        }
+        int index=0;
+        for(int i=0;i<3;i++){
+            while(count[i]>0){
+                nums[index++]=i;
+                count[i]--;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Three Consecutive Odds.java b/Three Consecutive Odds.java
new file mode 100644
index 0000000000..f6077e692c
--- /dev/null
+++ b/Three Consecutive Odds.java	
@@ -0,0 +1,14 @@
+class Solution {
+    public boolean threeConsecutiveOdds(int[] arr) {
+        // Loop through the array up to the third-to-last element
+        for (int i = 0; i < arr.length - 2; i++) {
+            // Check if the current element and the next two elements are all odd
+            int product=arr[i]*arr[i+1]*arr[i+2];
+            if(product% 2==1){
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/Type of Triangle.java b/Type of Triangle.java
new file mode 100644
index 0000000000..84cebe1a95
--- /dev/null
+++ b/Type of Triangle.java	
@@ -0,0 +1,15 @@
+class Solution {
+
+    public String triangleType(int[] nums) {
+        Arrays.sort(nums);
+        if (nums[0] + nums[1] <= nums[2]) {
+            return "none";
+        } else if (nums[0] == nums[2]) {
+            return "equilateral";
+        } else if (nums[0] == nums[1] || nums[1] == nums[2]) {
+            return "isosceles";
+        } else {
+            return "scalene";
+        }
+    }
+}
diff --git a/Valid parenthesis.java b/Valid parenthesis.java
new file mode 100644
index 0000000000..ff46fbc7af
--- /dev/null
+++ b/Valid parenthesis.java	
@@ -0,0 +1,22 @@
+bool isValid(char* s) {
+    int n = strlen(s);
+    char stack[n];
+    int top = -1;
+
+    for (int i = 0; i < n; i++) {
+        if (s[i] == '(' || s[i] == '{' || s[i] == '[') {
+            stack[++top] = s[i];
+        } else {
+            if (top == -1) {
+                return false;
+            }
+            char last = stack[top];
+            if ((last == '(' && s[i] == ')') || (last == '{' && s[i] == '}') || (last == '[' && s[i] == ']')) {
+                top--;
+            } else {
+                return false;
+            }
+        }
+    }
+    return top == -1;
+}
diff --git a/Zero Array Transformation I.java b/Zero Array Transformation I.java
new file mode 100644
index 0000000000..877d99dc55
--- /dev/null
+++ b/Zero Array Transformation I.java	
@@ -0,0 +1,24 @@
+class Solution {
+
+    public boolean isZeroArray(int[] nums, int[][] queries) {
+        int[] deltaArray = new int[nums.length + 1];
+        for (int[] query : queries) {
+            int left = query[0];
+            int right = query[1];
+            deltaArray[left] += 1;
+            deltaArray[right + 1] -= 1;
+        }
+        int[] operationCounts = new int[deltaArray.length];
+        int currentOperations = 0;
+        for (int i = 0; i < deltaArray.length; i++) {
+            currentOperations += deltaArray[i];
+            operationCounts[i] = currentOperations;
+        }
+        for (int i = 0; i < nums.length; i++) {
+            if (operationCounts[i] < nums[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/Zero Array Transformation III.java b/Zero Array Transformation III.java
new file mode 100644
index 0000000000..72ecfedf0e
--- /dev/null
+++ b/Zero Array Transformation III.java	
@@ -0,0 +1,32 @@
+class Solution {
+    public static int maxRemoval(int[] nums, int[][] queries) {
+        int n = nums.length, q = queries.length;
+        List<List<Integer>> qEnd = new ArrayList<>();
+        for (int i = 0; i < n; i++) qEnd.add(new ArrayList<>());
+        for (int[] query : queries) {
+            qEnd.get(query[0]).add(query[1]);
+        }
+
+        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
+        int[] cntQ = new int[n + 1];
+        int dec = 0;
+
+        for (int i = 0; i < n; i++) {
+            dec += cntQ[i];
+            for (int end : qEnd.get(i)) {
+                pq.offer(end);
+            }
+
+            int x = nums[i];
+            while (x > dec && !pq.isEmpty() && pq.peek() >= i) {
+                int k = pq.poll();
+                cntQ[k + 1]--;
+                dec++;
+            }
+
+            if (x > dec) return -1;
+        }
+
+        return pq.size();
+    }
+}
\ No newline at end of file