Add solution for finding the length of the longest increasing subsequ…

problems/general/longest_increasing_subsequence.md

@@ -0,0 +1,5 @@
+This problem was asked by **Microsoft**.
+
+Given an array of numbers, find the length of the longest increasing subsequence in the array. The subsequence does not necessarily have to be contiguous.
+
+For example, given the array `[0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15]`, the longest increasing subsequence has length `6`: it is `0, 2, 6, 9, 11, 15`.

solutions/general/longest_increasing_subsequence/Approach.java

@@ -0,0 +1,25 @@
+public class Approach {
+
+    private static int[] dp;
+
+    public static int longestIncreasingSubsequence(int[] arr) {
+
+        int max = 0;
+        for (int i = 0; i < arr.length; i++) {
+            dp[i] = 1;
+            for (int j = 0; j < i; j++) {
+                if (arr[i] > arr[j]) {
+                    dp[i] = dp[i] > dp[j] + 1 ? dp[i] : dp[j] + 1;
+                }
+            }
+            max = dp[i] > max ? dp[i] : max;
+        }
+        return max;
+    }
+
+    public static void main(String[] args) {
+        int[] arr = { 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15 };
+        dp = new int[arr.length];
+        System.err.println(longestIncreasingSubsequence(arr));
+    }
+}

solutions/general/longest_increasing_subsequence/approach.js

@@ -0,0 +1,23 @@
+function longestIncreasingSubsequence(nums) {
+  n = nums.length;
+  dp = Array(nums.length);
+  max = 0;
+
+  // Build the DP array
+  for (let i = 0; i < n; i++) {
+    dp[i] = 1;
+    for (let j = 0; j < i; j++) {
+      if (nums[i] > nums[j]) {
+        dp[i] = dp[i] > dp[j] + 1 ? dp[i] : dp[j] + 1;
+      }
+    }
+    max = max > dp[i] ? max : dp[i];
+  }
+
+  // The length of the longest increasing subsequence
+  return max;
+}
+
+// Example usage:
+let nums = [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15];
+console.log(longestIncreasingSubsequence(nums));

solutions/general/longest_increasing_subsequence/approach.py

@@ -0,0 +1,19 @@
+def length_of_lis(nums):
+    if not nums:
+        return 0
+
+    n = len(nums)
+    dp = [1] * n  # Initialize DP array with 1
+
+    # Build the DP array
+    for i in range(1, n):
+        for j in range(i):
+            if nums[i] > nums[j]:
+                dp[i] = max(dp[i], dp[j] + 1)
+
+    # The length of the longest increasing subsequence
+    return max(dp)
+
+# Example usage:
+nums = [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15]
+print(length_of_lis(nums))  # Output: 6