Merge branch 'master' into master

Author: sushant-sinha

README.md

@@ -0,0 +1 @@
+select extra as report_reason, count(distinct(post_id)) as report_count from Actions where action_date = '2019-07-04' and action = 'report' group by extra;

database/_1113.sql

@@ -0,0 +1,5 @@
+--# Write your MySQL query statement below
+select ifnull(round(count(distinct session_id)/count(distinct user_id), 2), 0.00)
+as average_sessions_per_user
+from Activity
+where activity_date between '2019-06-28' and '2019-07-27';

database/_1142.sql

@@ -0,0 +1,5 @@
+--# Write your MySQL query statement below
+select b.employee_id, b.name, count(*) as reports_count, round(avg(a.age)) as average_age
+from Employees a join Employees b on a.reports_to = b.employee_id
+group by b.employee_id
+order by b.employee_id

database/_1371.sql

@@ -0,0 +1,6 @@
+select stock_name, sum(
+    case
+        when operation = 'Buy' then -price
+            else price
+    end
+) as capital_gain_loss from Stocks group by stock_name;

database/_1393.sql

@@ -0,0 +1,13 @@
+--credit: https://leetcode.com/problems/the-most-frequently-ordered-products-for-each-customer/discuss/861257/simple-and-easy-solution-using-window-function
+
+select customer_id, product_id, product_name from
+(
+    select o.customer_id, o.product_id, p.product_name,
+    rank() over (partition by customer_id order by count(o.product_id) desc) as ranking
+    from Orders o
+    join Products p
+    on o.product_id = p.product_id
+    group by customer_id, product_id
+) tmp
+where ranking = 1
+order by customer_id, product_id

database/_1596.sql

@@ -0,0 +1,2 @@
+--# Write your MySQL query statement below
+select user_id, count(follower_id) as followers_count from followers group by user_id order by user_id;

database/_1729.sql

@@ -4,32 +4,6 @@
 import java.util.List;
 import java.util.Set;
 
-/**
- * 127. Word Ladder
- *
- *  Given two words (beginWord and endWord), and a dictionary's word list,
- *  find the length of shortest transformation sequence from beginWord to endWord, such that:
- *  Only one letter can be changed at a time.
- *  Each transformed word must exist in the word list. Note that beginWord is not a transformed word.
-
- For example,
-
- Given:
- beginWord = "hit"
- endWord = "cog"
- wordList = ["hot","dot","dog","lot","log","cog"]
-
- As one shortest transformation is "hit" -> "hot" -> "dot" -> "dog" -> "cog", return its length 5.
-
- Note:
-
- Return 0 if there is no such transformation sequence.
- All words have the same length.
- All words contain only lowercase alphabetic characters.
- You may assume no duplicates in the word list.
- You may assume beginWord and endWord are non-empty and are not the same.
- */
-
 public class _127 {
     public static class Solution1 {
 

src/main/java/com/fishercoder/solutions/_127.java

@@ -1,20 +1,16 @@
 package com.fishercoder.solutions;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class _1437 {
     public static class Solution1 {
         public boolean kLengthApart(int[] nums, int k) {
-            List<Integer> indexes = new ArrayList<>();
-            for (int i = 0; i < nums.length; i++) {
+            int lastOneIndex = nums[0] == 1 ? 0 : -1;
+            for (int i = 1; i < nums.length; i++) {
                 if (nums[i] == 1) {
-                    indexes.add(i);
-                }
-            }
-            for (int i = 0; i < indexes.size() - 1; i++) {
-                if (indexes.get(i + 1) - indexes.get(i) < k + 1) {
-                    return false;
+                    if (i - lastOneIndex <= k) {
+                        return false;
+                    } else {
+                        lastOneIndex = i;
+                    }
                 }
             }
             return true;

src/main/java/com/fishercoder/solutions/_1437.java

@@ -27,4 +27,38 @@ public String reverseWords(String s) {
             return stringBuilder.substring(0, stringBuilder.length() - 1).toString();
         }
     }
+
+    public static class Solution2 {
+        public String reverseWords(String s) {
+            int len = s.length();
+            int i = 0;
+            int j = 0;
+            String result = "";
+            while (i < len) {
+
+                // index i keeps track of the spaces and ignores them if found
+                while (i < len && s.charAt(i) == ' ') {
+                    i++;
+                }
+                if (i == len) {
+                    break;
+                }
+                j = i + 1;
+
+                // index j keeps track of non-space characters and gives index of the first occurrence of space after a non-space character
+                while (j < len && s.charAt(j) != ' ') {
+                    j++;
+                }
+                // word found
+                String word = s.substring(i, j);
+                if (result.length() == 0) {
+                    result = word;
+                } else {
+                    result = word + " " + result;
+                }
+                i = j + 1;
+            }
+            return result;
+        }
+    }
 }

src/main/java/com/fishercoder/solutions/_151.java

@@ -1,31 +1,5 @@
 package com.fishercoder.solutions;
 
-/**
- * 161. One Edit Distance
- *
- * Given two strings s and t, determine if they are both one edit distance apart.
- *
- * Note:
- * There are 3 possiblities to satisify one edit distance apart:
- * Insert a character into s to get t
- * Delete a character from s to get t
- * Replace a character of s to get t
- *
- * Example 1:
- * Input: s = "ab", t = "acb"
- * Output: true
- * Explanation: We can insert 'c' into s to get t.
- *
- * Example 2:
- * Input: s = "cab", t = "ad"
- * Output: false
- * Explanation: We cannot get t from s by only one step.
- *
- * Example 3:
- * Input: s = "1203", t = "1213"
- * Output: true
- * Explanation: We can replace '0' with '1' to get t.
- */
 public class _161 {
     public static class Solution1 {
         public boolean isOneEditDistance(String s, String t) {
@@ -48,9 +22,8 @@ public boolean isOneEditDistance(String s, String t) {
                         j++;
                     }
                 }
-                return diffCnt == 1
-                        || diffCnt
-                        == 0;//it could be the last char of the longer is the different one, in that case, diffCnt remains to be zero
+                return diffCnt == 1 || diffCnt == 0;
+                //it could be the last char of the longer is the different one, in that case, diffCnt remains to be zero
             } else if (s.length() == t.length()) {
                 int diffCnt = 0;
                 for (int i = 0; i < s.length(); i++) {

src/main/java/com/fishercoder/solutions/_161.java

@@ -0,0 +1,37 @@
+package com.fishercoder.solutions;
+
+import java.util.Arrays;
+
+public class _1641 {
+    public static class Solution1 {
+        /**
+         * I solved this problem using Math, no DP, recursion or backtracking techniques.
+         * Time: beat 100% submission consistently since it's O(n), essentialy it's O(1) because the contraints in the problem state: 1 <= n <= 50
+         * After writing out from n = 1 to 3, we can see the pattern.
+         * Detailed reasoning to be seen in my youtube video on my channel: https://www.youtube.com/fishercoder.
+         */
+        public int countVowelStrings(int n) {
+            if (n == 1) {
+                return 5;
+            }
+            int[] arr = new int[]{1, 1, 1, 1, 1};
+            int sum = 5;
+            for (int i = 2; i <= n; i++) {
+                int[] copy = new int[5];
+                for (int j = 0; j < arr.length; j++) {
+                    if (j == 0) {
+                        copy[j] = sum;
+                    } else {
+                        copy[j] = copy[j - 1] - arr[j - 1];
+                    }
+                }
+                arr = Arrays.copyOf(copy, 5);
+                sum = 0;
+                for (int j = 0; j < arr.length; j++) {
+                    sum += arr[j];
+                }
+            }
+            return sum;
+        }
+    }
+}

src/main/java/com/fishercoder/solutions/_1641.java

@@ -0,0 +1,30 @@
+package com.fishercoder.solutions;
+
+public class _1658 {
+    public static class Solution1 {
+        /**
+         * credit: https://leetcode.com/problems/minimum-operations-to-reduce-x-to-zero/discuss/936074/JavaPython-3-Sliding-window%3A-Longest-subarray-sum-to-the-target-sum(nums)-x.
+         */
+        public int minOperations(int[] nums, int x) {
+            int sum = 0;
+            for (int n : nums) {
+                sum += n;
+            }
+            int target = sum - x;
+            int len = nums.length;
+            int size = Integer.MIN_VALUE;
+            for (int left = -1, right = 0, windowSum = 0; right < len; right++) {
+                windowSum += nums[right];
+                while (left + 1 < len && windowSum > target) {
+                    left++;
+                    windowSum -= nums[left];
+                }
+                if (windowSum == target) {
+                    size = Math.max(size, right - left);
+                }
+            }
+            return size < 0 ? -1 : len - size;
+        }
+
+    }
+}

src/main/java/com/fishercoder/solutions/_1658.java

@@ -0,0 +1,25 @@
+package com.fishercoder.solutions;
+
+import java.util.TreeSet;
+
+public class _1675 {
+    public static class Solution1 {
+        public int minimumDeviation(int[] nums) {
+            TreeSet<Integer> treeSet = new TreeSet<>();
+            for (int num : nums) {
+                if (num % 2 == 1) {
+                    treeSet.add(num * 2);
+                } else {
+                    treeSet.add(num);
+                }
+            }
+            int minDev = treeSet.last() - treeSet.first();
+            while (treeSet.last() % 2 == 0) {
+                treeSet.add(treeSet.last() / 2);
+                treeSet.remove(treeSet.last());
+                minDev = Math.min(minDev, treeSet.last() - treeSet.first());
+            }
+            return minDev;
+        }
+    }
+}

src/main/java/com/fishercoder/solutions/_1675.java

@@ -0,0 +1,17 @@
+package com.fishercoder.solutions;
+
+public class _1680 {
+    public static class Solution1 {
+        public int concatenatedBinary(int n) {
+            final int MOD = 1000000007;
+            int result = 0;
+            for (int i = 1; i <= n; i++) {
+                String binary = Integer.toBinaryString(i);
+                for (int j = 0; j < binary.length(); j++) {
+                    result = (result * 2 + (binary.charAt(j) - '0')) % MOD;
+                }
+            }
+            return result;
+        }
+    }
+}

src/main/java/com/fishercoder/solutions/_1680.java

@@ -0,0 +1,22 @@
+package com.fishercoder.solutions;
+
+public class _1716 {
+    public static class Solution1 {
+        public int totalMoney(int n) {
+            int mondayMoney = 1;
+            int total = 0;
+            while (n > 0) {
+                int weekDays = 0;
+                int base = mondayMoney;
+                while (weekDays < 7 && n > 0) {
+                    total += base;
+                    base++;
+                    weekDays++;
+                    n--;
+                }
+                mondayMoney++;
+            }
+            return total;
+        }
+    }
+}

src/main/java/com/fishercoder/solutions/_1716.java

@@ -0,0 +1,36 @@
+package com.fishercoder.solutions;
+
+import java.util.Stack;
+
+public class _1717 {
+    public static class Solution1 {
+        public int maximumGain(String s, int x, int y) {
+            Stack<Character> stack1 = new Stack<>();
+            int big = x > y ? x : y;
+            int small = big == x ? y : x;
+            char first = x == big ? 'a' : 'b';
+            char second = first == 'a' ? 'b' : 'a';
+            int maximumGain = 0;
+            for (char c : s.toCharArray()) {
+                if (c == second && !stack1.isEmpty() && stack1.peek() == first) {
+                    stack1.pop();
+                    maximumGain += big;
+                } else {
+                    stack1.push(c);
+                }
+            }
+            Stack<Character> stack2 = new Stack<>();
+            while (!stack1.isEmpty()) {
+                char c = stack1.pop();
+                if (c == second && !stack2.isEmpty() && stack2.peek() == first) {
+                    stack2.pop();
+                    maximumGain += small;
+                } else {
+                    stack2.push(c);
+                }
+            }
+            return maximumGain;
+        }
+    }
+
+}