Merge branch 'neetcode-gh:main' into main

itsmohitnarayan · web-flow · commit e8dcc4527e2c · 2024-01-05T11:56:37.000+05:30
diff --git a/README.md b/README.md
diff --git a/csharp/1768-merge-strings-alternately.cs b/csharp/1768-merge-strings-alternately.cs
@@ -0,0 +1,18 @@
+public class Solution
+{
+    public string MergeAlternately(string word1, string word2)
+    {
+        var result = string.Empty;
+        var firstPointer = 0;
+        var secondPointer = 0;
+        while (firstPointer < word1.Length || secondPointer < word2.Length)
+        {
+            if (firstPointer < word1.Length)
+                result += word1[firstPointer++];
+
+            if (secondPointer < word2.Length)
+                result += word2[secondPointer++];
+        }
+        return result;
+    }
+}
diff --git a/java/0162-find-peak-element.java b/java/0162-find-peak-element.java
@@ -0,0 +1,14 @@
+class Solution {
+    public int findPeakElement(int[] nums) {
+        int l = 0, r = nums.length-1;
+        while(l<=r){
+            int m = l + (r-l)/2;
+            int left = (m-1==-1)?Integer.MIN_VALUE:nums[m-1];
+            int right = (m+1==nums.length)?Integer.MIN_VALUE:nums[m+1];
+            if(nums[m]>left && nums[m]>right) return m;
+            else if(nums[m]<left) r=m-1;
+            else l = m+1;
+        }
+        return 0;
+    }
+}
diff --git a/java/0455-assign-cookies.java b/java/0455-assign-cookies.java
@@ -0,0 +1,17 @@
+class Solution {
+    public int findContentChildren(int[] g, int[] s) {
+        Arrays.sort(g);
+        Arrays.sort(s);
+
+        int i = 0, j = 0;
+        while(i < g.length){
+            while(j < s.length && g[i] > s[j])
+                j += 1;
+            if(j == s.length)
+                break;
+            i += 1;
+            j += 1;        
+        }
+        return i;
+    }
+}
diff --git a/java/1624-largest-substring-between-two-equal-characters.java b/java/1624-largest-substring-between-two-equal-characters.java
@@ -0,0 +1,19 @@
+/*---------------------------
+  Time Complexity: O(n)
+  Space Complexity: O(1)
+-----------------------------*/  
+class Solution {
+    public int maxLengthBetweenEqualCharacters(String s) {
+        Map<Character, Integer> char_index = new HashMap<>();
+        int res = -1;
+
+        for(int i = 0; i < s.length(); i++){
+            if(char_index.containsKey(s.charAt(i))){
+                res = Math.max(res, i - char_index.get(s.charAt(i)) - 1);
+            }
+            else
+                char_index.put(s.charAt(i), i);
+        }
+        return res;
+    }
+}
diff --git a/java/1897-redistribute-characters-to-make-all-strings-equal.java b/java/1897-redistribute-characters-to-make-all-strings-equal.java
@@ -0,0 +1,17 @@
+class Solution {
+    public boolean makeEqual(String[] words) {
+        Map<Character, Integer> map = new HashMap<>();
+
+        for(String s: words){
+            for(char c: s.toCharArray()){
+                map.put(c, map.getOrDefault(c, 0) + 1);
+            }
+        }
+        int n = words.length;
+        for(char c: map.keySet()){
+            if(map.get(c) % n != 0)
+                return false;
+        }
+        return true;
+    }
+}
diff --git a/java/2300-successful-pairs-of-spells-and-potions.java b/java/2300-successful-pairs-of-spells-and-potions.java
@@ -0,0 +1,18 @@
+class Solution {
+    public int[] successfulPairs(
+        int[] spells, int[] potions, long success) {
+        int [] res = new int[spells.length];
+        Arrays.sort(potions);
+        for(int i=0;i<spells.length;i++){
+            int spell = spells[i];
+            int l = 0, r = potions.length-1;
+            while(l<=r){
+                int m = l+(r-l)/2;
+                if((long)spell*potions[m]>=success) r=m-1;
+                else l=m+1;
+            }
+            res[i] = (l<potions.length)?potions.length-l:0;
+        }
+        return res;
+    }
+}
diff --git a/kotlin/0455-assign-cookies.kt b/kotlin/0455-assign-cookies.kt
@@ -0,0 +1,17 @@
+class Solution {
+    fun findContentChildren(g: IntArray, s: IntArray): Int {
+        g.sort()
+        s.sort()
+
+        var i = 0
+        var j = 0
+        while (i < g.size) {
+            while (j < s.size && g[i] > s[j]) j++
+            if (j == s.size) break
+            i++
+            j++
+        }
+
+        return i
+    }
+}
diff --git a/kotlin/1155-number-of-dice-rolls-with-target-sum.kt b/kotlin/1155-number-of-dice-rolls-with-target-sum.kt
@@ -0,0 +1,43 @@
+// dp, space complexity down from O(n * t) down to O(t)
+class Solution {
+    fun numRollsToTarget(n: Int, k: Int, t: Int): Int {
+        val mod = 1_000_000_007
+        var dp = LongArray (t + 1)
+
+        dp[0] = 1
+
+        for (d in 0 until n) {
+            val nextDp = LongArray (t + 1)
+            for (m in 1..k) {
+                for (s in m..t)
+                    nextDp[s] = (nextDp[s] + dp[s - m]) % mod
+            }
+            dp = nextDp
+        }
+        
+        return dp[t].toInt()
+    }
+}
+
+// recursion + memo
+class Solution {
+    fun numRollsToTarget(n: Int, k: Int, t: Int): Int {
+        val mod = 1_000_000_007
+        val dp = Array (n + 1) { LongArray (t + 1) { -1L } }
+        
+        fun dfs(n: Int, s: Int): Long {
+            if (n < 0 || s > t) return 0
+            if (s == t && n == 0) return 1
+            if (dp[n][s] != -1L) return dp[n][s]
+
+            var res = 0L
+            for (m in 1..k)
+                res = (res + dfs(n - 1, s + m)) % mod
+            
+            dp[n][s] = res
+            return dp[n][s]
+        }
+
+        return (dfs(n, 0) % mod).toInt()
+    }
+}
diff --git a/kotlin/1335-minimum-difficulty-of-a-job-schedule.kt b/kotlin/1335-minimum-difficulty-of-a-job-schedule.kt
@@ -0,0 +1,30 @@
+class Solution {
+    fun minDifficulty(jobDifficulty: IntArray, d: Int): Int {
+        if (jobDifficulty.size < d) return -1
+
+        val cache = HashMap<String, Int>()
+
+        fun dfs(i: Int, d: Int, curMax: Int): Int {
+            if (i == jobDifficulty.size) {
+                return if (d == 0) 0 else INFINITY
+            }
+            if (d == 0) return INFINITY
+            cache["$i:$d:$curMax"]?.let { return it }
+
+            var max = maxOf(curMax, jobDifficulty[i])
+            var res = minOf(
+                dfs(i + 1, d, max),
+                max + dfs(i + 1, d - 1, -1)
+            )
+
+            cache["$i:$d:$max"] = res
+            return res
+        }
+
+        return dfs(0, d, -1)
+    }
+
+    companion object {
+        const val INFINITY = 400000
+    }
+}
diff --git a/kotlin/1531-string-compression-ii.kt b/kotlin/1531-string-compression-ii.kt
@@ -0,0 +1,27 @@
+class Solution {
+    fun getLengthOfOptimalCompression(s: String, k: Int): Int {
+        val cache = HashMap<String, Int>()
+        
+        fun count(i: Int, k: Int, prev: Char, prevCount: Int): Int {
+            cache["$i:$k:$prev:$prevCount"]?.let { return it }
+            if (k < 0) return Integer.MAX_VALUE
+            if (i == s.length) return 0
+
+            var res = -1
+            if (s[i] == prev) {
+                val incr = if (prevCount in setOf(1, 9, 99)) 1 else 0
+                res = incr + count(i + 1, k, s[i], prevCount + 1)
+            } else {
+                res = minOf(
+                    count(i + 1, k - 1, prev, prevCount),
+                    1 + count(i + 1, k, s[i], 1)
+                )
+            }
+
+            cache["$i:$k:$prev:$prevCount"] = res
+            return res
+        }
+
+        return count(0, k, 'Z', 0)
+    }
+}
diff --git a/kotlin/1578-minimum-time-to-make-rope-colorful.kt b/kotlin/1578-minimum-time-to-make-rope-colorful.kt
@@ -0,0 +1,20 @@
+class Solution {
+    fun minCost(colors: String, neededTime: IntArray): Int {
+        var l = 0
+        var res = 0
+        for (r in 1 until colors.length) {
+            if (colors[l] == colors[r]) {
+                if (neededTime[l] < neededTime[r]) {
+                    res += neededTime[l]
+                    l = r
+                } else {
+                    res += neededTime[r]
+                }
+            } else {
+                l = r
+            }
+        }
+
+       return res
+    }
+}
diff --git a/kotlin/1624-largest-substring-between-two-equal-characters.kt b/kotlin/1624-largest-substring-between-two-equal-characters.kt
@@ -0,0 +1,34 @@
+class Solution {
+    fun maxLengthBetweenEqualCharacters(s: String): Int {
+        val charIndex = HashMap<Char, Int>()
+        var res = -1
+
+         for ((i, c) in s.withIndex()) {
+            if (c in charIndex)
+                res = maxOf(res, i - charIndex[c]!! - 1)
+            else
+                charIndex[c] = i
+        }
+
+        return res
+    }
+}
+
+// Similar but slightly different way
+class Solution {
+    fun maxLengthBetweenEqualCharacters(s: String): Int {
+        val letters = Array (26) { intArrayOf(302, -302) }
+        var res = -1
+        for (l in letters.indices) {
+            for ((i, c) in s.withIndex()) {
+                if (c == ('a' + l)) {
+                    letters[l][0] = minOf(letters[l][0], i)
+                    letters[l][1] = maxOf(letters[l][1], i)
+                    res = maxOf(res, letters[l][1] - letters[l][0] - 1)
+                }
+            }
+        }
+
+        return res
+    }
+}
diff --git a/kotlin/1897-redistribute-characters-to-make-all-strings-equal.kt b/kotlin/1897-redistribute-characters-to-make-all-strings-equal.kt
@@ -0,0 +1,27 @@
+class Solution {
+    fun makeEqual(words: Array<String>): Boolean {
+        val n = words.size
+        val count = IntArray (26)
+
+        for (word in words) {
+            for (c in word)
+                count[c - 'a']++
+        }
+
+        for (cnt in count) {
+            if (cnt % n != 0)
+                return false
+        }
+
+        return true
+    }
+}
+
+// or do it kotlin way!
+class Solution {
+    fun makeEqual(words: Array<String>) = words
+    .joinToString("")
+    .groupingBy { it }
+    .eachCount()
+    .all { it.value % words.size == 0 }
+}
diff --git a/kotlin/2125-number-of-laser-beams-in-a-bank.kt b/kotlin/2125-number-of-laser-beams-in-a-bank.kt
@@ -0,0 +1,25 @@
+class Solution {
+    fun numberOfBeams(bank: Array<String>): Int {
+        var prev = bank[0].count { it == '1'}
+        var res = 0
+
+        for (i in 1 until bank.size) {
+            val cur = bank[i].count { it == '1'}
+            if (cur > 0) {
+                res += (prev * cur)
+                prev = cur
+            }
+        }
+
+        return res
+    }
+}
+
+// or do it the kotlin way!
+class Solution {
+    fun numberOfBeams(bank: Array<String>) = bank
+        .map { it.count { it == '1' } }
+        .filterNot { it == 0 }
+        .zipWithNext { a, b -> a * b }
+        .sum()
+}
diff --git a/kotlin/2610-convert-an-array-into-a-2d-array-with-conditions.kt b/kotlin/2610-convert-an-array-into-a-2d-array-with-conditions.kt
@@ -0,0 +1,16 @@
+class Solution {
+    fun findMatrix(nums: IntArray): List<List<Int>> {
+        val count = HashMap<Int, Int>()
+        val res = mutableListOf<MutableList<Int>>()
+
+        for (n in nums) {
+            var row = count[n] ?: 0
+            if (res.size == row)
+                res.add(mutableListOf<Int>())
+            res[row].add(n)
+            count[n] = (count[n] ?: 0) + 1
+        }
+
+        return res
+    }
+}
diff --git a/kotlin/2870-minimum-number-of-operations-to-make-array-empty.kt b/kotlin/2870-minimum-number-of-operations-to-make-array-empty.kt
@@ -0,0 +1,13 @@
+class Solution {
+    fun minOperations(nums: IntArray): Int {
+        val count = nums.asIterable().groupingBy { it }.eachCount()
+
+        var res = 0
+        for (c in count.values) {
+            if (c == 1) return -1
+            res += (c / 3) + if (c % 3 > 0) 1 else 0 // "Ceil" function
+        }
+
+        return res
+    }
+}
diff --git a/python/0027-remove-element.py b/python/0027-remove-element.py
@@ -6,3 +6,20 @@ def removeElement(self, nums: List[int], val: int) -> int:
                 nums[k] = nums[i]
                 k += 1
         return k
+
+# Optimized solution with the same time and space complexity
+class Solution:
+    def removeElement(self, nums: List[int], val: int) -> int:
+        # Avoid unessary copy operations in a previous solution, when k == i and nums[i] != val 
+        # by swapping nums[i] and the last element of the array (nums[n])
+        n = len(nums)
+        i = 0
+
+        while i < n:
+            if nums[i] == val:
+                nums[i], nums[n - 1] = nums[n - 1], nums[i]
+                n -= 1  # decrement the length of the array by discarding the last element
+            else:
+                i += 1
+        
+        return n
diff --git a/python/0106-construct-binary-tree-from-inorder-and-postorder-traversal.py b/python/0106-construct-binary-tree-from-inorder-and-postorder-traversal.py
diff --git a/python/1396-design-underground-system.py b/python/1396-design-underground-system.py
