🚀 Day 33 of DSA Problem Solving – Max Consecutive Ones & More!

✅ Problem 1: Max Consecutive Ones

Given a binary array nums, return the maximum number of consecutive 1s in the array.

🧠 Approach:

We iterate through the array and keep a running count of consecutive 1s. If we encounter a 0, we reset the current count. We also track the maximum count found so far.

🧮 Time Complexity:

• O(n) — We traverse the array once.

💾 Space Complexity:

• O(1) — Only constant extra space is used.

💻 Code:

var findMaxConsecutiveOnes = function(nums) {
    let current_Count = 0;
    let max_Count = 0;

    for (let i = 0; i < nums.length; i++) {
        if (nums[i] === 1) {
            current_Count++;
            if (current_Count > max_Count) {
                max_Count = current_Count;
            }
        } else {
            current_Count = 0;
        }
    }

    return max_Count;
};

📥 Example:

Input: [1,1,0,1,1,1]
Output: 3
Explanation: The maximum number of consecutive 1s is three.

✅ Problem 2: Consecutive Characters

Given a string s, return the power of the string. The power of the string is the maximum length of a substring that contains only one unique character.

🧠 Approach:

We iterate through the string, comparing each character with the previous one. If it's the same, increase the current count. Otherwise, reset the counter. Track the max count during the iteration.

🧮 Time Complexity:

• O(n) — Single pass through the string.

💾 Space Complexity:

• O(1) — No additional data structures needed.

💻 Code:

var maxPower = function(s) {
    let current_Count = 0;
    let max_Count = 0;
    let char = '';

    for (let i = 0; i < s.length + 1; i++) {
        if (s[i] === char) {
            current_Count++;
        } else {
            char = s[i];
            current_Count = 1;
        }

        if (current_Count > max_Count) {
            max_Count = current_Count;
        }
    }

    return max_Count;
};

📥 Example:

Input: "abbcccddddeeeeedcba"
Output: 5
Explanation: The longest sequence is "eeeee" with length 5.

✅ Problem 3: Longest Continuous Increasing Subsequence (LCIS)

Given an unsorted array of integers nums, return the length of the longest strictly increasing subsequence that is continuous.

🧠 Approach:

We iterate through the array and check if the current element is greater than the previous one. If so, increase the current length. Otherwise, reset. Keep track of the max length encountered.

🧮 Time Complexity:

• O(n) — Single pass through the string.

💾 Space Complexity:

• O(1) — Constant space.

💻 Code:

var findLengthOfLCIS = function(nums) {
    let maxLen = 0;
    let currentLen = 1;

    if (nums.length === 0) return 0;

    for (let i = 1; i < nums.length; i++) {
        if (nums[i] > nums[i - 1]) {
            currentLen++;
        } else {
            if (currentLen > maxLen) {
                maxLen = currentLen;
            }
            currentLen = 1;
        }
    }

    return Math.max(maxLen, currentLen);
};

📥 Example:

Input: [1,3,5,4,7]
Output: 3
Explanation: The LCIS is [1,3,5] with length 3.