Code Is Added

Author: anjha1

1491.average-salary-excluding-the-minimum-and-maximum-salary/AverageSalaryExcludingTheMinimumAndMaximumSalary.java

@@ -0,0 +1,17 @@
+class AverageSalaryExcludingTheMinimumAndMaximumSalary {
+    public double average(int[] salary) {
+        double max = Integer.MIN_VALUE;
+        double min = Integer.MAX_VALUE;
+        double sum = 0, count = salary.length - 2;
+        for (int s: salary) {
+            if (s > max) {
+                max = s;
+            }
+            if (s < min) {
+                min = s;
+            }
+            sum += s;
+        }
+        return (sum - min - max) / count;
+    }
+}

1491.average-salary-excluding-the-minimum-and-maximum-salary/README.md

@@ -0,0 +1,7 @@
+# [1491. Average Salary Excluding the Minimum and Maximum Salary](https://leetcode.com/problems/average-salary-excluding-the-minimum-and-maximum-salary/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `salary`.
+- Space Complexity: $O(1)$.

1498.number-of-subsequences-that-satisfy-the-given-sum-condition/NumberOfSubsequencesThatSatisfyTheGivenSumCondition.java

@@ -0,0 +1,25 @@
+import java.util.Arrays;
+
+class NumberOfSubsequencesThatSatisfyTheGivenSumCondition {
+    static final int modulo = (int) Math.pow(10, 9) + 7;
+
+    public int numSubseq(int[] nums, int target) {
+        Arrays.sort(nums);
+        int[] tmp = new int[nums.length];
+        tmp[0] = 1;
+        for (int i = 1; i < nums.length; i++) {
+            tmp[i] = (tmp[i - 1] * 2) % modulo;
+        }
+        int res = 0;
+        int l = 0, r = nums.length - 1;
+        while (l <= r) {
+            if (nums[l] + nums[r] > target) {
+                r--;
+            } else {
+                res = (res + tmp[r - l]) % modulo;
+                l++;
+            }
+        }
+        return res;
+    }
+}

1498.number-of-subsequences-that-satisfy-the-given-sum-condition/README.md

@@ -0,0 +1,2 @@
+# [1498. Number of Subsequences That Satisfy the Given Sum Condition](https://leetcode.com/problems/number-of-subsequences-that-satisfy-the-given-sum-condition/)
+

1523.count-odd-numbers-in-an-interval-range/CountOddNumbersInAnIntervalRange.java

@@ -0,0 +1,7 @@
+class CountOddNumbersInAnIntervalRange {
+    public int countOdds(int low, int high) {
+        if ((low & 1) == 0)
+            low++;
+        return low > high ? 0 : (high - low) / 2 + 1;
+    }
+}

1523.count-odd-numbers-in-an-interval-range/README.md

@@ -0,0 +1,8 @@
+# [1523. Count Odd Numbers in an Interval Range](https://leetcode.com/problems/count-odd-numbers-in-an-interval-range/)
+
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(1)$.
+- Space Complexity: $O(1)$.

1531.string-compression-ii/README.md

@@ -0,0 +1,2 @@
+# [1531. String Compression II](https://leetcode.com/problems/string-compression-ii/)
+

1531.string-compression-ii/StringCompressionIi.java

@@ -0,0 +1,28 @@
+import java.util.Arrays;
+
+class StringCompressionIi {
+    public int getLengthOfOptimalCompression(String s, int k) {
+        int n = s.length();
+        int[][] dp = new int[110][110];
+        for (int[] d : dp)
+            Arrays.fill(d, 9999);
+
+        dp[0][0] = 0;
+        for (int i = 1; i <= n; i++) {
+            for (int j = 0; j <= k; j++) {
+                int cnt = 0, del = 0;
+                for (int l = i; l >= 1; l--) {
+                    if (s.charAt(l - 1) == s.charAt(i - 1)) cnt++;
+                    else del++;
+                    if (j - del >= 0) {
+                        dp[i][j] = Math.min(dp[i][j], dp[l - 1][j - del] + 1 + (cnt >= 100 ? 3 : cnt >= 10 ? 2 : cnt >= 2 ? 1 : 0));
+                    }
+                }
+                if (j > 0) {
+                    dp[i][j] = Math.min(dp[i][j], dp[i - 1][j - 1]);
+                }
+            }
+        }
+        return dp[n][k];
+    }
+}

1539.kth-missing-positive-number/KthMissingPositiveNumber.java

@@ -0,0 +1,9 @@
+class KthMissingPositiveNumber {
+    public int findKthPositive(int[] arr, int k) {
+        for (int i = 0; i < arr.length; i++) {
+            if (arr[i] <= k)
+                k++;
+        }
+        return k;
+    }
+}

1539.kth-missing-positive-number/README.md

@@ -0,0 +1,7 @@
+# [1539. Kth Missing Positive Number](https://leetcode.com/problems/kth-missing-positive-number/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$. $n$ is the length of `arr`.
+- Space Complexity: $O(1)$.

1544.make-the-string-great/MakeTheStringGreat.java

@@ -0,0 +1,19 @@
+import java.util.Stack;
+
+class MakeTheStringGreat {
+    public String makeGood(String s) {
+        Stack<Character> stack = new Stack<>();
+        for (char c : s.toCharArray()) {
+            if (!stack.isEmpty() && Math.abs(stack.peek() - c) == 32) {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+
+        StringBuilder ans = new StringBuilder();
+        for (char c : stack)
+            ans.append(c);
+        return ans.toString();
+    }
+}

1544.make-the-string-great/README.md

@@ -0,0 +1,2 @@
+# [1544. Make The String Great](https://leetcode.com/problems/make-the-string-great/)
+

1572.matrix-diagonal-sum/MatrixDiagonalSum.java

@@ -0,0 +1,19 @@
+class MatrixDiagonalSum {
+    public int diagonalSum(int[][] mat) {
+        int sum = 0;
+        int n = mat.length;
+        for (int i = 0; i < n; i++) {
+            sum += mat[i][i];
+        }
+        for (int i = n - 1; i >= 0; i--) {
+            sum += mat[i][n - 1 - i];
+        }
+        if (n % 2 == 0) {
+            return sum;
+        } else {
+            int index = n / 2;
+            sum -= mat[index][index];
+        }
+        return sum;
+    }
+}

1572.matrix-diagonal-sum/README.md

@@ -0,0 +1,7 @@
+# [1572. Matrix Diagonal Sum](https://leetcode.com/problems/matrix-diagonal-sum/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n)$.
+- Space Complexity: $O(1)$.

1578.minimum-time-to-make-rope-colorful/MinimumTimeToMakeRopeColorful.java

@@ -0,0 +1,17 @@
+class MinimumTimeToMakeRopeColorful {
+    public int minCost(String colors, int[] neededTime) {
+        int totalTime = 0;
+        int l = 0, r = 0;
+        while (l < neededTime.length) {
+            int currTotal = 0, currMax = 0;
+            while (r < neededTime.length && colors.charAt(l) == colors.charAt(r)) {
+                currTotal += neededTime[r];
+                currMax = Math.max(currMax, neededTime[r]);
+                r++;
+            }
+            totalTime += currTotal - currMax;
+            l = r;
+        }
+        return totalTime;
+    }
+}

1578.minimum-time-to-make-rope-colorful/README.md

@@ -0,0 +1,2 @@
+# [1578. Minimum Time to Make Rope Colorful](https://leetcode.com/problems/minimum-time-to-make-rope-colorful/)
+

1626.best-team-with-no-conflicts/BestTeamWithNoConflicts.java

@@ -0,0 +1,24 @@
+import java.util.Arrays;
+
+class BestTeamWithNoConflicts {
+    public int bestTeamScore(int[] scores, int[] ages) {
+        int n = scores.length;
+        Integer[] order = new Integer[n];
+        for (int i = 0; i < n; i++)
+            order[i] = i;
+        Arrays.sort(order, (a, b) -> ages[a] == ages[b] ? scores[a] - scores[b] : ages[a] - ages[b]);
+        int[] dp = new int[n];
+        int res = 0;
+        for (int i = 0; i < dp.length; i++) {
+            int currI = order[i];
+            dp[i] = scores[currI];
+            for (int j = 0; j < i; j++) {
+                int currJ = order[j];
+                if (scores[currI] >= scores[currJ])
+                    dp[i] = Math.max(dp[i], dp[j] + scores[currI]);
+            }
+            res = Math.max(res, dp[i]);
+        }
+        return res;
+    }
+}

1626.best-team-with-no-conflicts/README.md

@@ -0,0 +1,7 @@
+# [1626. Best Team With No Conflicts](https://leetcode.com/problems/best-team-with-no-conflicts/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n^2)$. $n$ is the length of `scores`.
+- Space Complexity: $O(n)$. We use an extra array order, so the space complexity is $O(n)$.

1642.furthest-building-you-can-reach/FurthestBuildingYouCanReach.java

@@ -0,0 +1,17 @@
+import java.util.PriorityQueue;
+
+class FurthestBuildingYouCanReach {
+    public int furthestBuilding(int[] heights, int bricks, int ladders) {
+        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
+        for (int i = 0; i < heights.length - 1; i++) {
+            int diff = heights[i + 1] - heights[i];
+            if (diff <= 0) continue;
+            minHeap.offer(diff);
+            if (minHeap.size() > ladders && minHeap.peek() != null) {
+                bricks -= minHeap.poll();
+            }
+            if (bricks < 0) return i;
+        }
+        return heights.length - 1;
+    }
+}

1642.furthest-building-you-can-reach/README.md

@@ -0,0 +1,3 @@
+# [1642. Furthest Building You Can Reach](https://leetcode.com/problems/furthest-building-you-can-reach/)
+
+# (https://assets.leetcode.com/uploads/2020/10/27/q4.gif)