Example 1:

Input: arr = [2,6,4,1]
Output: false
Explanation: There are no three consecutive odds.

Example 2:

Input: arr = [1,2,34,3,4,5,7,23,12]
Output: true
Explanation: [5,7,23] are three consecutive odds.

Constraints:

• 1 <= arr.length <= 1000
• 1 <= arr[i] <= 1000

Solution: Counting

Time complexity: O(n)
Space complexity: O(1)

class Solution {
public:
  bool threeConsecutiveOdds(vector<int>& arr) {       
    int count = 0;
    for (int x : arr) {
      if (x & 1) {
        if (++count == 3) return true;
      } else {
        count = 0;
      }
    }
    return false;      
  }
};

The post 花花酱 LeetCode 1550. Three Consecutive Odds appeared first on Huahua's Tech Road.

Given an array of integers arr. Return the number of sub-arrays with odd sum.

As the answer may grow large, the answer must be computed modulo 10^9 + 7.

Example 1:

Input: arr = [1,3,5]
Output: 4
Explanation: All sub-arrays are [[1],[1,3],[1,3,5],[3],[3,5],[5]]
All sub-arrays sum are [1,4,9,3,8,5].
Odd sums are [1,9,3,5] so the answer is 4.

Example 2:

Input: arr = [2,4,6]
Output: 0
Explanation: All sub-arrays are [[2],[2,4],[2,4,6],[4],[4,6],[6]]
All sub-arrays sum are [2,6,12,4,10,6].
All sub-arrays have even sum and the answer is 0.

Example 3:

Input: arr = [1,2,3,4,5,6,7]
Output: 16

Example 4:

Input: arr = [100,100,99,99]
Output: 4

Example 5:

Input: arr = [7]
Output: 1

Constraints:

• 1 <= arr.length <= 10^5
• 1 <= arr[i] <= 100

Solution: DP

We would like to know how many subarrays end with arr[i] have odd or even sums.

dp[i][0] := # end with arr[i] has even sum
dp[i][1] := # end with arr[i] has even sum

if arr[i] is even:

  dp[i][0]=dp[i-1][0] + 1, dp[i][1]=dp[i-1][1]

else:

  dp[i][1]=dp[i-1][0], dp[i][0]=dp[i-1][0] + 1

ans = sum(dp[i][1])

Time complexity: O(n)
Space complexity: O(n) -> O(1)

class Solution {
public:
  int numOfSubarrays(vector<int>& arr) {
    const int n = arr.size();
    constexpr int kMod = 1e9 + 7;
    // dp[i][0] # of subarrays ends with a[i-1] have even sums.
    // dp[i][1] # of subarrays ends with a[i-1] have odd sums.
    vector<vector<int>> dp(n + 1, vector<int>(2));
    long ans = 0;
    for (int i = 1; i <= n; ++i) {
      if (arr[i - 1] & 1) {
        dp[i][0] = dp[i - 1][1];
        dp[i][1] = dp[i - 1][0] + 1;
      } else {
        dp[i][0] = dp[i - 1][0] + 1;
        dp[i][1] = dp[i - 1][1];
      }
      ans += dp[i][1];
    }
    return ans % kMod;
  }
};

// Author: Huahua
class Solution {
  public int numOfSubarrays(int[] arr) {
    long ans = 0, odd = 0, even = 0;
    for (int x : arr) {
      even += 1;
      if (x % 2 == 1) {
        long t = even; even = odd; odd = t;
      }
      ans += odd;
    }
    return (int)(ans % (int)(1e9 + 7));
  }
}

# Author: Huahua
class Solution:
  def numOfSubarrays(self, arr: List[int]) -> int:
    ans, odd, even = 0, 0, 0
    for x in arr:
      if x & 1:
        odd, even = even + 1, odd
      else:
        odd, even = odd, even + 1
      ans += odd
    return ans % int(1e9 + 7)

The post 花花酱 LeetCode 1524. Number of Sub-arrays With Odd Sum appeared first on Huahua's Tech Road.

Example 1:

Input: low = 3, high = 7
Output: 3
Explanation: The odd numbers between 3 and 7 are [3,5,7].

Example 2:

Input: low = 8, high = 10
Output: 1
Explanation: The odd numbers between 8 and 10 are [9].

Constraints:

• 0 <= low <= high <= 10^9

Solution: Math

The count of odd numbers between [1, low – 1] is low / 2
e.g. low = 6, we have [1,3,5] in range [1, 5] and count is 6/2 = 3.
The count of odd numbers between [1, high] is (high + 1) / 2
e.g. high = 7, we have [1,3,5,7] in range [1, 7] and count is (7+1) / 2 = 4

Then the count of odd numbers in range [low, high] = count(1, high) – count(1, low-1)
e.g. in range [6, 7] we only have [7], count: 4 – 3 = 1

ans = (high + 1) / 2 – low / 2

Time complexity: O(1)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int countOdds(int low, int high) {
    return (high + 1) / 2 - low / 2;
  }
};

The post 花花酱 LeetCode 1523. Count Odd Numbers in an Interval Range appeared first on Huahua's Tech Road.

Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.

You may return any answer array that satisfies this condition.

<strong>Input: </strong><span id="example-input-1-1">[3,1,2,4]</span>
<strong>Output: </strong><span id="example-output-1">[2,4,3,1]</span>
The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.

// Author: Huahua, 44 ms
class Solution {
public:
  vector<int> sortArrayByParity(vector<int>& A) {
    vector<int> even;
    vector<int> odd;
    for (int a : A) {
      if (a % 2) odd.push_back(a);
      else even.push_back(a);
    }
    even.insert(end(even), begin(odd), end(odd));
    return even;
  }
};

Solution 2: Stable sort by key % 2

Time complexity: O(nlogn)

Space complexity: O(1) in-place

// Author: Huahua, 52 ms
class Solution {
public:
  vector<int> sortArrayByParity(vector<int>& A) {
    stable_sort(begin(A), end(A), [](int a, int b){
      return a % 2 < b % 2;
    });
    return A;
  }
};

The post 花花酱 LeetCode 905. Sort Array By Parity appeared first on Huahua's Tech Road.