Given a list of non-negative numbers and a target integer k, write a function to check if the array has a continuous subarray of size at least 2 that sums up to the multiple of k, that is, sums up to n*k where n is also an integer.

Example 1:

Input: [23, 2, 4, 6, 7],  k=6
Output: True
Explanation: Because [2, 4] is a continuous subarray of size 2 and sums up to 6.

Example 2:

Input: [23, 2, 6, 4, 7],  k=6
Output: True
Explanation: Because [23, 2, 6, 4, 7] is an continuous subarray of size 5 and sums up to 42.

Note:

1. The length of the array won’t exceed 10,000.
2. You may assume the sum of all the numbers is in the range of a signed 32-bit integer.

Special case:

nums = [0,0], k = 0, return = True

Solution: Prefix Sum Reminder

Time complexity: O(n)

Space complexity: O(min(n, k))

// Author: Huahua
// Running time: 16 ms (<99.62%)
class Solution {
public:
  bool checkSubarraySum(vector<int>& nums, int k) {    
    unordered_map<int, int> m; // sum % k -> first index
    m[0] = -1;
    int sum = 0;
    for (int i = 0; i < nums.size(); ++i) {
      sum += nums[i];
      if (k != 0) sum %= k;      
      if (m.count(sum)) {
        if (i - m.at(sum) > 1) return true;
      } else {
        m[sum] = i;
      }
    }
    return false;
  }
};

Related Problems

• 花花酱 LeetCode 560. Subarray Sum Equals K
• 花花酱 LeetCode 525. Contiguous Array

The post 花花酱 LeetCode 523. Continuous Subarray Sum appeared first on Huahua's Tech Road.

Problem:

A self-dividing number is a number that is divisible by every digit it contains.

For example, 128 is a self-dividing number because 128 % 1 == 0, 128 % 2 == 0, and 128 % 8 == 0.

Also, a self-dividing number is not allowed to contain the digit zero.

Given a lower and upper number bound, output a list of every possible self dividing number, including the bounds if possible.

Example 1:

Input: 
left = 1, right = 22
Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]

Note:

• The boundaries of each input argument are 1 <= left <= right <= 10000.

Idea:

Brute Force

Time Complexity: O(n)

Space Complexity: O(1)

Solution:

C++

// Author: Huahua
// Runtime: 3 ms
class Solution {
public:
    vector<int> selfDividingNumbers(int left, int right) {
        vector<int> ans;
        for (int n = left; n <= right; ++n) {
            int t = n;
            bool valid = true;
            while (t && valid) {
                const int r = t % 10;
                if (r == 0 || n % r)
                    valid = false;
                t /= 10;
            }
            if (valid) ans.push_back(n);
        }
        return ans;
    }
};

String

// Author: Huahua
// Runtime: 6 ms
class Solution {
public:
    vector<int> selfDividingNumbers(int left, int right) {
        vector<int> ans;
        for (int n = left; n <= right; ++n) {
            const string t = std::to_string(n);
            bool valid = true;
            for (const char c : t) {
                if (c == '0' || n % (c - '0')) {
                    valid = false;
                    break;
                }
            }
            if (valid) ans.push_back(n);
        }
        return ans;
    }
};

Related Problems:

• [解题报告] LeetCode 611. Valid Triangle Number

The post 花花酱 LeetCode 728. Self Dividing Numbers appeared first on Huahua's Tech Road.