Merge pull request gahogg#28 from gahogg/Missing-Soln

Added Brute Force Solution

Author: gahogg

Max Consecutive Ones III - Leetcode 1004/brute force.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int longestOnes(vector<int>& nums, int k) {
+        int n = nums.size();
+        int maxLen = 0;
+
+        // Iterate over all starting points of subarrays
+        for (int i = 0; i < n; ++i) {
+
+            // Check each subarray starting from `i`
+            for (int j = i; j < n; ++j) {
+                int zeroCount = 0;
+                for (int c = i; c <= j; ++c) {
+                    if (nums[c] == 0) 
+                        zeroCount++;
+                }
+
+                // If the number of zeroes exceeds k, 
+                // update the maximum length
+                if (zeroCount <= k) {
+                    maxLen = max(maxLen, j - i + 1);
+                }
+
+            }
+        }
+
+        return maxLen;
+    }
+};

Max Consecutive Ones III - Leetcode 1004/brute force.java

@@ -0,0 +1,27 @@
+public class Solution {
+    public int longestOnes(int[] nums, int k) {
+        int maxLength = 0;
+
+        // Iterate over all starting points
+        for (int i = 0; i < nums.length; i++) {
+
+            // Iterate over all possible subarrays starting from i
+            for (int j = i; j < nums.length; j++) {
+
+                int zeroCount = 0;
+                for (int c = i; c <= j; ++c) {
+                    if (nums[c] == 0)
+                        ++zeroCount;
+                }
+
+                // Update maxLength if this subarray is valid
+                if (zeroCount <= k) {
+                    maxLength = Math.max(maxLength, j - i + 1);
+                }
+                
+            }
+        }
+
+        return maxLength;
+    }
+}

Max Consecutive Ones III - Leetcode 1004/brute force.js

@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var longestOnes = function(nums, k) {
+    let maxLength = 0;
+
+    // Iterate over all starting points
+    for (let i = 0; i < nums.length; i++) {
+
+        // Iterate over all possible subarrays starting from i
+        for (let j = i; j < nums.length; j++) {
+            let zeroCount = 0;
+            for (let c = i; c <= j; ++c) {
+                if (nums[c] == 0)
+                    ++zeroCount;
+            }
+            
+            // If the number of zeroes exceeds k, 
+            // update the maximum length
+            if (zeroCount <= k) {
+                maxLength = Math.max(maxLength, j - i + 1);
+            }
+            
+        }
+    }
+
+    return maxLength;
+};

Max Consecutive Ones III - Leetcode 1004/brute force.py

@@ -0,0 +1,19 @@
+class Solution(object):
+    def longestOnes(self, nums, k):
+        """
+        :type nums: List[int]
+        :type k: int
+        :rtype: int
+        """
+        longest_ones = 0
+        
+        # Iterate over all starting points
+        for i in range(len(nums)):
+
+            # Iterate over all possible subarrays starting from i
+            for j in range(i + 1, len(nums) + 1):
+                window_len = j - i
+                num_zeros = nums[i:j].count(0)  # O(k) operation
+                if num_zeros <= k:
+                    longest_ones = max(longest_ones, window_len)
+        return longest_ones

Maximum Average Subarray I - Leetcode 643/brute force.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    double findMaxAverage(const vector<int>& nums, int k) {
+        double max_avg = 0;
+
+        // setting max_avg to any constant numeric value 
+        // here is incorrect!!! 
+        // So initialize it with some values from the input
+        for (int i = 0; i < k; ++i)
+            max_avg += nums[i];
+        max_avg /= k;
+
+        for (int i = 0; i <= nums.size() - k; ++i) {
+            double avg = 0;
+            for (int j = i; j < i + k; ++j)
+                avg += nums[j];
+            avg /= k;
+            max_avg = max(max_avg, avg); 
+        }
+        return max_avg;
+    }
+};

Maximum Average Subarray I - Leetcode 643/brute force.java

@@ -0,0 +1,22 @@
+class Solution {
+    public double findMaxAverage(int[] nums, int k) {
+        double max_avg = 0;
+
+        // setting max_avg to any constant numeric value 
+        // here is incorrect!!! 
+        // So initialize it with some values from the input
+        for (int i = 0; i < k; ++i)
+            max_avg += nums[i];
+        max_avg /= k;
+
+        for (int i = 0; i <= nums.length - k; ++i) {
+            double avg = 0;
+            for (int j = i; j < i + k; ++j)
+                avg += nums[j];
+            avg /= k;
+            max_avg = Math.max(max_avg, avg); 
+        }
+        return max_avg;
+
+    }
+}

Maximum Average Subarray I - Leetcode 643/brute force.js

@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var findMaxAverage = function(nums, k) {
+    const avg = (vals, start, len) => {
+        let sum = 0;
+        for (let i = start; i < start + len; i++) {
+            sum += vals[i];
+        }
+        return sum / len;
+    };
+
+    // Calculate initial maximum average
+    let maxAvg = avg(nums, 0, k);
+    for (let i = 0; i <= nums.length - k; i++) {
+        maxAvg = Math.max(maxAvg, avg(nums, i, k));
+    }
+
+    return maxAvg;
+};

Maximum Average Subarray I - Leetcode 643/brute force.py

@@ -0,0 +1,20 @@
+class Solution(object):
+    def findMaxAverage(self, nums, k):
+        """
+        :type nums: List[int]
+        :type k: int
+        :rtype: float
+        """
+
+        def avg(vals):
+            return sum(vals) / float(len(vals))
+
+        # Note, setting max_avg to any constant numeric value 
+        # here is incorrect!!! 
+        # Say 0, if nums = [-1, -2, -3, -4], k = 2, 
+        # the output would be incorrect
+        max_avg = avg(nums[:k])
+        for i in range(len(nums) - k + 1):
+            max_avg = max(max_avg, avg(nums[i:i+k])) # avg is O(k)
+        return max_avg
+