solution is added

Author: anjha1

0263.ugly-number/README.md

@@ -0,0 +1 @@
+# [263. Ugly Number](https://leetcode.com/problems/ugly-number/)

0263.ugly-number/UglyNumber.java

@@ -0,0 +1,17 @@
+class UglyNumber {
+    private int keepDividingWhenDivisible(int dividend, int divisor) {
+        while (dividend % divisor == 0) {
+            dividend /= divisor;
+        }
+        return dividend;
+    }
+
+    public boolean isUgly(int n) {
+        if (n <= 0) return false;
+        for (int factor : new int[]{2, 3, 5}) {
+            n = keepDividingWhenDivisible(n, factor);
+        }
+
+        return n == 1;
+    }
+}

0268.missing-number/MissingNumber.java

@@ -0,0 +1,7 @@
+class MissingNumber {
+    public int missingNumber(int[] nums) {
+        int ret = 0;
+        for (int i = 0; i < nums.length; i++) ret = ret ^ i ^ nums[i];
+        return ret ^ nums.length;
+    }
+}

0268.missing-number/README.md

@@ -0,0 +1,2 @@
+# [268. Missing Number](https://leetcode.com/problems/missing-number/)
+

0278.first-bad-version/FirstBadVersion.java

@@ -0,0 +1,17 @@
+/* The isBadVersion API is defined in the parent class VersionControl.
+      boolean isBadVersion(int version); */
+
+public class FirstBadVersion extends VersionControl {
+    public int firstBadVersion(int n) {
+        int l = 1, h = n;
+        while (l < h) {
+            int mid = l + (h - l) / 2;
+            if (isBadVersion(mid)) {
+                h = mid;
+            } else {
+                l = mid + 1;
+            }
+        }
+        return l;
+    }
+}

0278.first-bad-version/README.md

@@ -0,0 +1 @@
+# [278. First Bad Version](https://leetcode.com/problems/first-bad-version/)

0279.perfect-squares/PerfectSquares.java

@@ -0,0 +1,17 @@
+import java.util.Arrays;
+
+class PerfectSquares {
+    public int numSquares(int n) {
+        int[] dp = new int[n + 1];
+        Arrays.fill(dp, Integer.MAX_VALUE);
+        dp[0] = 0;
+
+        for (int i = 1; i <= n; i++) {
+            for (int j = 1; j <= Math.sqrt(i); j++) {
+                dp[i] = Math.min(dp[i], (dp[i - (j * j)] + 1));
+            }
+        }
+
+        return dp[n];
+    }
+}

0279.perfect-squares/README.md

@@ -0,0 +1 @@
+# [279. Perfect Squares](https://leetcode.com/problems/perfect-squares/)

0283.move-zeroes/MoveZeroes.java

@@ -0,0 +1,13 @@
+class MoveZeroes {
+    public void moveZeroes(int[] nums) {
+        int idx = 0;
+        for (int num : nums) {
+            if (num != 0) {
+                nums[idx++] = num;
+            }
+        }
+        while (idx < nums.length) {
+            nums[idx++] = 0;
+        }
+    }
+}

0283.move-zeroes/README.md

@@ -0,0 +1 @@
+# [283. Move Zeroes](https://leetcode.com/problems/move-zeroes/)

0287.find-the-duplicate-number/FindTheDuplicateNumber.java

@@ -0,0 +1,15 @@
+class FindTheDuplicateNumber {
+    public int findDuplicate(int[] nums) {
+        int l = 1, h = nums.length - 1;
+        while (l <= h) {
+            int mid = l + (h - l) / 2;
+            int cnt = 0;
+            for (int i = 0; i < nums.length; i++) {
+                if (nums[i] <= mid) cnt++;
+            }
+            if (cnt > mid) h = mid - 1;
+            else l = mid + 1;
+        }
+        return l;
+    }
+}

0287.find-the-duplicate-number/README.md

@@ -0,0 +1,2 @@
+# [287. Find the Duplicate Number](https://leetcode.com/problems/find-the-duplicate-number/)
+

0290.word-pattern/README.md

@@ -0,0 +1,7 @@
+# [290. Word Pattern](https://leetcode.com/problems/word-pattern/)
+
+
+Complexity Analysis:
+
+- Time Complexity: $O(n+m)$. $n$ is the length of s and $m$ is the length of pattern. Each character is only traverse at most once.
+- Space Complexity: $O(n+m)$. The size of two maps is $n$ and $m$ respectively.

0290.word-pattern/WordPattern.java

@@ -0,0 +1,27 @@
+import java.util.HashMap;
+import java.util.Map;
+
+class WordPattern {
+    public boolean wordPattern(String pattern, String s) {
+        Map<String, Character> str2ch = new HashMap<>();
+        Map<Character, String> ch2str = new HashMap<>();
+        int n = s.length(), i = 0;
+        for (int p = 0; p < pattern.length(); p++) {
+            char currentPattern = pattern.charAt(p);
+            if (i >= n) return false;
+            int j = i;
+            while (j < n && s.charAt(j) != ' ') {
+                j++;
+            }
+            String word = s.substring(i, j);
+            if (str2ch.containsKey(word) && str2ch.get(word) != currentPattern)
+                return false;
+            if (ch2str.containsKey(currentPattern) && !word.equals(ch2str.get(currentPattern)))
+                return false;
+            str2ch.put(word, currentPattern);
+            ch2str.put(currentPattern, word);
+            i = j + 1;
+        }
+        return i >= n;
+    }
+}

0295.find-median-from-data-stream/FindMedianFromDataStream.java

@@ -0,0 +1,43 @@
+import java.util.Collections;
+import java.util.PriorityQueue;
+
+class MedianFinder {
+    private final PriorityQueue<Integer> small = new PriorityQueue<>(Collections.reverseOrder());
+    private final PriorityQueue<Integer> large = new PriorityQueue<>();
+    private boolean even = true;
+
+    public MedianFinder() {
+        
+    }
+    
+    public void addNum(int num) {
+        if (even) {
+            large.offer(num);
+            small.offer(large.poll());
+        } else {
+            small.offer(num);
+            large.offer(small.poll());
+        }
+        even = !even;
+    }
+    
+    public double findMedian() {
+        if (even)
+            if (!small.isEmpty() && !large.isEmpty())
+                return (small.peek() + large.peek()) / 2.0;
+            else
+                return 0;
+        else
+            if (!small.isEmpty())
+                return small.peek();
+            else
+                return 0;
+    }
+}
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * MedianFinder obj = new MedianFinder();
+ * obj.addNum(num);
+ * double param_2 = obj.findMedian();
+ */

0295.find-median-from-data-stream/README.md

@@ -0,0 +1,2 @@
+# [295. Find Median from Data Stream](https://leetcode.com/problems/find-median-from-data-stream/)
+

0299.bulls-and-cows/BullsAndCows.java

@@ -0,0 +1,32 @@
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+class BullsAndCows {
+    public String getHint(String secret, String guess) {
+        int bulls = 0;
+        for (int i = 0; i < secret.length(); i++) {
+            if (secret.charAt(i) == guess.charAt(i)) {
+                bulls++;
+                secret = secret.substring(0, i) + secret.substring(i + 1);
+                guess = guess.substring(0, i) + guess.substring(i + 1);
+                i--;
+            }
+        }
+
+        HashMap<Character, Integer> map = new HashMap<>();
+        for (char c : secret.toCharArray()) {
+            map.put(c, map.getOrDefault(c, 0) + 1);
+        }
+
+        int cows = 0;
+        for (char c : guess.toCharArray()) {
+            if (map.containsKey(c) && map.get(c) != 0) {
+                cows++;
+                map.put(c, map.get(c) - 1);
+            }
+        }
+
+        return bulls + "A" + cows + "B";
+    }
+}

0299.bulls-and-cows/README.md

@@ -0,0 +1 @@
+# [299. Bulls and Cows](https://leetcode.com/problems/bulls-and-cows/)

0300.longest-increasing-subsequence/LongestIncreasingSubsequence.java

@@ -0,0 +1,18 @@
+import java.util.Arrays;
+
+class LongestIncreasingSubsequence {
+    public int lengthOfLIS(int[] nums) {
+        int[] dp = new int[nums.length];
+        dp[nums.length - 1] = 1;
+        for (int i = nums.length - 2; i >= 0; i--) {
+            int max = 1;
+            for (int j = i + 1; j < nums.length; j++) {
+                if (nums[i] < nums[j]) {
+                    if (max < dp[j] + 1) max = dp[j] + 1;
+                }
+            }
+            dp[i] = max;
+        }
+        return Arrays.stream(dp).max().getAsInt();
+    }
+}

0300.longest-increasing-subsequence/README.md

@@ -0,0 +1 @@
+# [300. Longest Increasing Subsequence](https://leetcode.com/problems/longest-increasing-subsequence/)

0307.range-sum-query-mutable/README.md

@@ -0,0 +1,2 @@
+# [307. Range Sum Query - Mutable](https://leetcode.com/problems/range-sum-query-mutable/)
+

0307.range-sum-query-mutable/RangeSumQueryMutable.java

@@ -0,0 +1,42 @@
+class NumArray {
+    private int[] sums;
+    private int[] nums;
+
+    private int getSum(int i) {
+        int sum = 0;
+        while (i > 0) {
+            sum += sums[i];
+            i = i - (i & (-i));
+        }
+        return sum;
+    }
+
+    public NumArray(int[] nums) {
+        this.nums = new int[nums.length];
+        sums = new int[nums.length + 1];
+        for (int i = 0; i < nums.length; i++) {
+            update(i, nums[i]);
+        }
+    }
+    
+    public void update(int index, int val) {
+        int diff = val - nums[index];
+        int j = index + 1;
+        while (j < sums.length) {
+            sums[j] += diff;
+            j = j + (j & (-j));
+        }
+        nums[index] = val;
+    }
+    
+    public int sumRange(int left, int right) {
+        return getSum(right + 1) - getSum(left);
+    }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * obj.update(index,val);
+ * int param_2 = obj.sumRange(left,right);
+ */

0309.best-time-to-buy-and-sell-stock-with-cooldown/BestTimeToBuyAndSellStockWithCooldown.java

@@ -0,0 +1,15 @@
+class BestTimeToBuyAndSellStockWithCooldown {
+    public int maxProfit(int[] prices) {
+        int n = prices.length;
+        if (n == 0) return 0;
+
+        int[][] f = new int[n][3];
+        f[0][0] = -prices[0];
+        for (int i = 1; i < n; i++) {
+            f[i][0] = Math.max(f[i - 1][0], f[i - 1][2] - prices[i]);
+            f[i][1] = f[i - 1][0] + prices[i];
+            f[i][2] = Math.max(f[i - 1][1], f[i - 1][2]);
+        }
+        return Math.max(f[n - 1][1], f[n - 1][2]);
+    }
+}

0309.best-time-to-buy-and-sell-stock-with-cooldown/README.md

@@ -0,0 +1,2 @@
+# [309. Best Time to Buy and Sell Stock with Cooldown](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/)
+

0315.count-of-smaller-numbers-after-self/CountOfSmallerNumbersAfterSelf.java

@@ -0,0 +1,34 @@
+import java.util.Arrays;
+import java.util.List;
+
+class CountOfSmallerNumbersAfterSelf {
+    public List<Integer> countSmaller(int[] nums) {
+        int min = 20001;
+        int max = -1;
+        for (int num : nums) {
+            min = Math.min(min, num);
+            max = Math.max(max, num);
+        }
+
+        min--;
+        int[] count = new int[max - min + 1];
+        Integer[] result = new Integer[nums.length];
+        for (int i = nums.length-1; i >=0; i--) {
+            int k = nums[i] - min - 1;
+            int c = 0;
+            do {
+                c += count[k];
+                k -= (-k&k);
+            } while (k > 0);
+            result[i] = c;
+
+            k = nums[i]-min;
+            while (k < count.length) {
+                count[k]++;
+                k += (-k & k);
+            }
+        }
+
+        return Arrays.asList(result);
+    }
+}

0315.count-of-smaller-numbers-after-self/README.md

@@ -0,0 +1,2 @@
+# [315. Count of Smaller Numbers After Self](https://leetcode.com/problems/count-of-smaller-numbers-after-self/)
+

0318.maximum-product-of-word-lengths/MaximumProductOfWordLengths.java

@@ -0,0 +1,20 @@
+class MaximumProductOfWordLengths {
+    public int maxProduct(String[] words) {
+        int n = words.length;
+        int[] val = new int[n];
+        for (int i = 0; i < n; i++) {
+            for (char c : words[i].toCharArray()) {
+                val[i] |= 1 << (c - 'a');
+            }
+        }
+        int ret = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = i + 1; j < n; j++) {
+                if ((val[i] & val[j]) == 0) {
+                    ret = Math.max(ret, words[i].length() * words[j].length());
+                }
+            }
+        }
+        return ret;
+    }
+}

0318.maximum-product-of-word-lengths/README.md

@@ -0,0 +1 @@
+# [318. Maximum Product of Word Lengths](https://leetcode.com/problems/maximum-product-of-word-lengths/)