Create Count of Subarrays in an Array

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;
+    }
+}

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);
+
+        }    
+
+    };
+

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;
+        }
+    };

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;
+          }
+        }
+    };

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;
+    }
+};

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;
+    }
+};

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;
+
+    }
+};

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];
+    }
+}

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;
+    }
+}

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;
+    }
+}

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>

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;
+    }
+}

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;
+    }
+}

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;
+    }
+}