Merge branch 'neetcode-gh:main' into main

Author: tayyabferozi

README.md

@@ -0,0 +1,25 @@
+typedef unsigned long long ll;
+class Solution {
+public:
+    bool solve(string & s , ll last , int index,int cnt){
+
+        if(index >= s.size()) return cnt > 1;
+
+        ll num = 0;
+        bool ret = false;
+
+        for(int i = index ; i < s.size() ; i++){
+            num = num * 10;
+            num += (s[i] - '0');
+
+            if(last == -1 || last == num + 1){
+                ret |= solve(s , num , i + 1 , cnt + 1);
+            }else if(last != -1 && num >= last)break;
+        }
+
+        return ret;
+    }
+    bool splitString(string s) {
+        return solve(s,-1,0,0);
+    }
+};

cpp/1849-splitting-a-string-into-descending-consecutive-values.cpp

@@ -0,0 +1,31 @@
+class Solution {
+    fun permuteUnique(nums: IntArray): List<List<Int>> {
+        val count = HashMap<Int, Int>()
+        val permut = LinkedList<Int>()
+        val res = LinkedList<LinkedList<Int>>()
+        
+        for (n in nums) count[n] = count.getOrDefault(n, 0) + 1
+
+        fun backtrack() {
+            if (permut.size == nums.size) {
+                res.add(LinkedList(permut))
+                return
+            }
+            
+            for (n in count.keys) {
+                if (count[n]!! > 0) {
+                    permut.addLast(n)
+                    count[n] = count[n]!! - 1
+
+                    backtrack()
+
+                    count[n] = count[n]!! + 1
+                    permut.removeLast()
+                }     
+            }
+        }
+
+        backtrack()
+        return res
+    }
+}

kotlin/0047-permutations-ii.kt

@@ -1,16 +1,15 @@
 class Solution {
     fun lengthOfLIS(nums: IntArray): Int {
-        val dp = IntArray(nums.size){1}
-        for(i in nums.size-1 downTo 0){
-            for(j in i+1 until nums.size){
-                if(nums[i] < nums[j]){
+        val dp = IntArray(nums.size) {1}
+
+        for (i in nums.size-1 downTo 0) {
+            for (j in i + 1 until nums.size) {
+                if (nums[i] < nums[j]) {
                     dp[i] = maxOf(dp[i], 1 + dp[j])
                 }
             }
         }
-        var max = 0
-        for(n in dp)
-            max = maxOf(max, n)
-        return max
+
+        return dp.max()!!
     }
 }

kotlin/0300-longest-increasing-subsequence.kt

@@ -0,0 +1,86 @@
+/*
+* DFS + memoization solution
+*/
+class Solution {
+    fun findNumberOfLIS(nums: IntArray): Int {
+        val memo = HashMap<Int, Pair<Int, Int>>()  
+        var lisLen = 0
+        var lisCount = 0
+
+        fun dfs(i: Int): Pair<Int, Int> {
+            if (i in memo)
+                return memo[i]!!
+
+            var maxLen = 1
+            var maxCount = 1
+            for (j in i+1 until nums.size) {
+                if (nums[i] < nums[j]) {
+                    val (curLen, curCount) = dfs(j)
+                    if (curLen + 1 > maxLen) {
+                        maxLen = curLen + 1
+                        maxCount = curCount
+                    } else if (curLen + 1 == maxLen) {
+                        maxCount += curCount
+                    }
+                }
+            }
+
+            if (maxLen > lisLen) {
+                lisLen = maxLen
+                lisCount = maxCount
+            } else if (maxLen == lisLen) {
+                lisCount += maxCount
+            }
+
+            memo[i] = (maxLen to maxCount)
+            return memo[i]!!
+        }
+
+        for (i in nums.indices)
+            dfs(i)
+        
+        return lisCount
+    }
+}
+
+/*
+* DP solution
+*/
+class Solution {
+    fun findNumberOfLIS(nums: IntArray): Int {
+        val lis = IntArray(nums.size) {1}
+        val count = IntArray(nums.size)
+
+        var lisLen = 0
+        var lisCount = 0
+        for (i in nums.size-1 downTo 0) {
+            var maxLen = 1
+            var maxCount = 1
+
+            for (j in i+1 until nums.size) {
+                if (nums[i] < nums[j]) {
+                    val curLen = lis[j]
+                    val curCount = count[j]
+                    if (curLen + 1 > maxLen) {
+                        maxLen = curLen + 1
+                        maxCount = curCount
+                    } else if (curLen + 1 == maxLen) {
+                        maxCount += curCount
+                    }
+                }
+            }
+
+            if (maxLen > lisLen) {
+                lisLen = maxLen
+                lisCount = maxCount
+            } else if (maxLen == lisLen) {
+                lisCount += maxCount
+            }
+
+            lis[i] = maxLen
+            count[i] = maxCount
+        }
+        
+        return lisCount
+    }
+}

kotlin/0673-number-of-longest-increasing-subsequence.kt

@@ -0,0 +1,23 @@
+class Solution {
+    fun maxScore(cardPoints: IntArray, k: Int): Int {
+        if (cardPoints.size == k) return cardPoints.sum()
+        var l = cardPoints.size - k
+        var r = cardPoints.lastIndex
+
+        var maxScore = 0
+        var currentScore = 0
+        // the sum of the initial sub-array
+        for (i in l..r) {
+            maxScore += cardPoints[i]
+            currentScore += cardPoints[i]
+        }
+
+        while (true) {
+            currentScore -= cardPoints[l++ % cardPoints.size]
+            currentScore += cardPoints[++r % cardPoints.size]
+            maxScore = maxOf(maxScore, currentScore)
+            if (l % cardPoints.size == 0) break
+        }
+        return maxScore
+    }
+}

kotlin/1423-maximum-points-you-can-obtain-from-cards.kt

@@ -0,0 +1,33 @@
+class Solution {
+    fun maxSumMinProduct(nums: IntArray): Int {
+        val prefix = LongArray(nums.size + 1)
+        val stack = ArrayDeque<Pair<Int, Long>>()
+        val mod = 1000000007L
+        
+        for (i in nums.indices) {
+            prefix[i + 1] = prefix[i] + nums[i]
+        }
+
+        var res = 0L
+        for ((i, n) in nums.withIndex()) {
+            var start = i
+
+            while (stack.isNotEmpty() && stack.peekLast().second > n) {
+                val (lastStart, value) = stack.removeLast()
+                val total = prefix[i] - prefix[lastStart]
+                res = maxOf(res, total * value)
+                start = lastStart
+            }
+
+            stack.addLast(start to n.toLong())
+        }
+        
+        for ((start, value) in stack) {
+            val total = prefix[nums.size] - prefix[start]
+            res = maxOf(res, total * value)
+        }
+
+
+        return (res % mod).toInt()
+    }
+}